transform.js 70 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688
  1. /**
  2. * @license Copyright (c) 2003-2016, CKSource - Frederico Knabben. All rights reserved.
  3. * For licensing, see LICENSE.md.
  4. */
  5. /* bender-tags: treemodel, operation */
  6. 'use strict';
  7. import RootElement from '/ckeditor5/core/treemodel/rootelement.js';
  8. import Node from '/ckeditor5/core/treemodel/node.js';
  9. import Position from '/ckeditor5/core/treemodel/position.js';
  10. import Range from '/ckeditor5/core/treemodel/range.js';
  11. import transform from '/ckeditor5/core/treemodel/operation/transform.js';
  12. import InsertOperation from '/ckeditor5/core/treemodel/operation/insertoperation.js';
  13. import AttributeOperation from '/ckeditor5/core/treemodel/operation/attributeoperation.js';
  14. import RootAttributeOperation from '/ckeditor5/core/treemodel/operation/rootattributeoperation.js';
  15. import MoveOperation from '/ckeditor5/core/treemodel/operation/moveoperation.js';
  16. import NoOperation from '/ckeditor5/core/treemodel/operation/nooperation.js';
  17. describe( 'transform', () => {
  18. let root, op, nodeA, nodeB, expected, baseVersion;
  19. beforeEach( () => {
  20. root = new RootElement( null );
  21. nodeA = new Node();
  22. nodeB = new Node();
  23. baseVersion = 0;
  24. } );
  25. function expectOperation( op, params ) {
  26. for ( let i in params ) {
  27. if ( params.hasOwnProperty( i ) ) {
  28. if ( i == 'type' ) {
  29. expect( op ).to.be.instanceof( params[ i ] );
  30. }
  31. else if ( params[ i ] instanceof Array ) {
  32. expect( op[ i ].length ).to.equal( params[ i ].length );
  33. for ( let j = 0; j < params[ i ].length; j++ ) {
  34. expect( op[ i ][ j ] ).to.equal( params[ i ][ j ] );
  35. }
  36. } else if ( params[ i ] instanceof Position || params[ i ] instanceof Range ) {
  37. expect( op[ i ].isEqual( params[ i ] ) ).to.be.true;
  38. } else {
  39. expect( op[ i ] ).to.equal( params[ i ] );
  40. }
  41. }
  42. }
  43. }
  44. describe( 'InsertOperation', () => {
  45. let nodeC, nodeD, position;
  46. beforeEach( () => {
  47. nodeC = new Node();
  48. nodeD = new Node();
  49. position = new Position( root, [ 0, 2, 2 ] );
  50. op = new InsertOperation( position, [ nodeA, nodeB ], baseVersion );
  51. expected = {
  52. type: InsertOperation,
  53. position: Position.createFromPosition( position ),
  54. baseVersion: baseVersion + 1
  55. };
  56. } );
  57. describe( 'by InsertOperation', () => {
  58. it( 'target at different position: no position update', () => {
  59. let transformBy = new InsertOperation(
  60. new Position( root, [ 1, 3, 2 ] ),
  61. [ nodeC, nodeD ],
  62. baseVersion
  63. );
  64. let transOp = transform( op, transformBy );
  65. expect( transOp.length ).to.equal( 1 );
  66. expectOperation( transOp[ 0 ], expected );
  67. } );
  68. it( 'target at offset before: increment offset', () => {
  69. let transformBy = new InsertOperation(
  70. new Position( root, [ 0, 2, 0 ] ),
  71. [ nodeC, nodeD ],
  72. baseVersion
  73. );
  74. let transOp = transform( op, transformBy );
  75. expected.position.offset += 2;
  76. expect( transOp.length ).to.equal( 1 );
  77. expectOperation( transOp[ 0 ], expected );
  78. } );
  79. it( 'target at same offset and is important: increment offset', () => {
  80. let transformBy = new InsertOperation(
  81. new Position( root, [ 0, 2, 2 ] ),
  82. [ nodeC, nodeD ],
  83. baseVersion
  84. );
  85. let transOp = transform( op, transformBy );
  86. expected.position.offset += 2;
  87. expect( transOp.length ).to.equal( 1 );
  88. expectOperation( transOp[ 0 ], expected );
  89. } );
  90. it( 'target at same offset and is less important: no position update', () => {
  91. let transformBy = new InsertOperation(
  92. new Position( root, [ 0, 2, 2 ] ),
  93. [ nodeC, nodeD ],
  94. baseVersion
  95. );
  96. let transOp = transform( transformBy, true );
  97. expect( transOp.length ).to.equal( 1 );
  98. expectOperation( transOp[ 0 ], expected );
  99. } );
  100. it( 'target at offset after: no position update', () => {
  101. let transformBy = new InsertOperation(
  102. new Position( root, [ 0, 2, 3 ] ),
  103. [ nodeC, nodeD ],
  104. baseVersion
  105. );
  106. let transOp = transform( op, transformBy );
  107. expect( transOp.length ).to.equal( 1 );
  108. expectOperation( transOp[ 0 ], expected );
  109. } );
  110. it( 'target before node from path: increment index on path', () => {
  111. let transformBy = new InsertOperation(
  112. new Position( root, [ 0, 1 ] ),
  113. [ nodeC, nodeD ],
  114. baseVersion
  115. );
  116. let transOp = transform( op, transformBy );
  117. expected.position.path[ 1 ] += 2;
  118. expect( transOp.length ).to.equal( 1 );
  119. expectOperation( transOp[ 0 ], expected );
  120. } );
  121. it( 'target after node from path: no position update', () => {
  122. let transformBy = new InsertOperation(
  123. new Position( root, [ 0, 6 ] ),
  124. [ nodeC, nodeD ],
  125. baseVersion
  126. );
  127. let transOp = transform( op, transformBy );
  128. expect( transOp.length ).to.equal( 1 );
  129. expectOperation( transOp[ 0 ], expected );
  130. } );
  131. } );
  132. describe( 'by AttributeOperation', () => {
  133. it( 'no position update', () => {
  134. let transformBy = new AttributeOperation(
  135. Range.createFromPositionAndShift( position, 2 ),
  136. 'foo',
  137. null,
  138. 'bar',
  139. baseVersion
  140. );
  141. let transOp = transform( op, transformBy );
  142. expect( transOp.length ).to.equal( 1 );
  143. expectOperation( transOp[ 0 ], expected );
  144. } );
  145. } );
  146. describe( 'by RootAttributeOperation', () => {
  147. it( 'no position update', () => {
  148. let transformBy = new RootAttributeOperation(
  149. root,
  150. 'foo',
  151. null,
  152. 'bar',
  153. baseVersion
  154. );
  155. let transOp = transform( op, transformBy );
  156. expect( transOp.length ).to.equal( 1 );
  157. expectOperation( transOp[ 0 ], expected );
  158. } );
  159. } );
  160. describe( 'by MoveOperation', () => {
  161. it( 'range and target are different than insert position: no position update', () => {
  162. let transformBy = new MoveOperation(
  163. new Position( root, [ 1, 3, 2 ] ),
  164. 2,
  165. new Position( root, [ 2, 1 ] ),
  166. baseVersion
  167. );
  168. let transOp = transform( op, transformBy );
  169. expect( transOp.length ).to.equal( 1 );
  170. expectOperation( transOp[ 0 ], expected );
  171. } );
  172. it( 'range is before insert position offset: decrement offset', () => {
  173. let transformBy = new MoveOperation(
  174. new Position( root, [ 0, 2, 0 ] ),
  175. 1,
  176. new Position( root, [ 1, 1 ] ),
  177. baseVersion
  178. );
  179. let transOp = transform( op, transformBy );
  180. expected.position.offset--;
  181. expect( transOp.length ).to.equal( 1 );
  182. expectOperation( transOp[ 0 ], expected );
  183. } );
  184. it( 'range offset is after insert position offset: no position update', () => {
  185. let transformBy = new MoveOperation(
  186. new Position( root, [ 0, 2, 5 ] ),
  187. 1,
  188. new Position( root, [ 1, 1 ] ),
  189. baseVersion
  190. );
  191. let transOp = transform( op, transformBy );
  192. expect( transOp.length ).to.equal( 1 );
  193. expectOperation( transOp[ 0 ], expected );
  194. } );
  195. it( 'target offset before insert position offset: increment offset', () => {
  196. let transformBy = new MoveOperation(
  197. new Position( root, [ 1, 1 ] ),
  198. 2,
  199. new Position( root, [ 0, 2, 0 ] ),
  200. baseVersion
  201. );
  202. let transOp = transform( op, transformBy );
  203. expected.position.offset += 2;
  204. expect( transOp.length ).to.equal( 1 );
  205. expectOperation( transOp[ 0 ], expected );
  206. } );
  207. it( 'target offset after insert position offset: no position update', () => {
  208. let transformBy = new MoveOperation(
  209. new Position( root, [ 1, 1 ] ),
  210. 2,
  211. new Position( root, [ 0, 2, 5 ] ),
  212. baseVersion
  213. );
  214. let transOp = transform( op, transformBy );
  215. expect( transOp.length ).to.equal( 1 );
  216. expectOperation( transOp[ 0 ], expected );
  217. } );
  218. it( 'target offset same as insert position offset and is important: increment offset', () => {
  219. let transformBy = new MoveOperation(
  220. new Position( root, [ 1, 1 ] ),
  221. 2,
  222. new Position( root, [ 0, 2, 2 ] ),
  223. baseVersion
  224. );
  225. let transOp = transform( op, transformBy );
  226. expected.position.offset += 2;
  227. expect( transOp.length ).to.equal( 1 );
  228. expectOperation( transOp[ 0 ], expected );
  229. } );
  230. it( 'target offset same as insert position offset and is less important: no position update', () => {
  231. let transformBy = new MoveOperation(
  232. new Position( root, [ 1, 1 ] ),
  233. 2,
  234. new Position( root, [ 0, 2, 2 ] ),
  235. baseVersion
  236. );
  237. let transOp = transform( op, transformBy, true );
  238. expect( transOp.length ).to.equal( 1 );
  239. expectOperation( transOp[ 0 ], expected );
  240. } );
  241. it( 'range is before node from insert position path: decrement index on path', () => {
  242. let transformBy = new MoveOperation(
  243. new Position( root, [ 0, 0 ] ),
  244. 1,
  245. new Position( root, [ 1, 0 ] ),
  246. baseVersion
  247. );
  248. let transOp = transform( op, transformBy );
  249. expected.position.path[ 1 ] -= 1;
  250. expect( transOp.length ).to.equal( 1 );
  251. expectOperation( transOp[ 0 ], expected );
  252. } );
  253. it( 'range is after node from insert position path: no position update', () => {
  254. let transformBy = new MoveOperation(
  255. new Position( root, [ 0, 4 ] ),
  256. 2,
  257. new Position( root, [ 1, 0 ] ),
  258. baseVersion
  259. );
  260. let transOp = transform( op, transformBy );
  261. expect( transOp.length ).to.equal( 1 );
  262. expectOperation( transOp[ 0 ], expected );
  263. } );
  264. it( 'target before node from insert position path: increment index on path', () => {
  265. let transformBy = new MoveOperation(
  266. new Position( root, [ 1, 0 ] ),
  267. 2,
  268. new Position( root, [ 0, 0 ] ),
  269. baseVersion
  270. );
  271. let transOp = transform( op, transformBy );
  272. expected.position.path[ 1 ] += 2;
  273. expect( transOp.length ).to.equal( 1 );
  274. expectOperation( transOp[ 0 ], expected );
  275. } );
  276. it( 'target after node from insert position path: no position update', () => {
  277. let transformBy = new MoveOperation(
  278. new Position( root, [ 1, 0 ] ),
  279. 2,
  280. new Position( root, [ 0, 4 ] ),
  281. baseVersion
  282. );
  283. let transOp = transform( op, transformBy );
  284. expect( transOp.length ).to.equal( 1 );
  285. expectOperation( transOp[ 0 ], expected );
  286. } );
  287. it( 'range has node that contains insert position: update position', () => {
  288. let transformBy = new MoveOperation(
  289. new Position( root, [ 0, 1 ] ),
  290. 2,
  291. new Position( root, [ 1, 1 ] ),
  292. baseVersion
  293. );
  294. let transOp = transform( op, transformBy );
  295. expected.position.path = [ 1, 2, 2 ];
  296. expect( transOp.length ).to.equal( 1 );
  297. expectOperation( transOp[ 0 ], expected );
  298. } );
  299. it( 'range contains insert position (on same level): update position', () => {
  300. let transformBy = new MoveOperation(
  301. new Position( root, [ 0, 2, 0 ] ),
  302. 4,
  303. new Position( root, [ 1, 0 ] ),
  304. baseVersion
  305. );
  306. let transOp = transform( op, transformBy );
  307. expected.position.path = [ 1, 2 ];
  308. expect( transOp.length ).to.equal( 1 );
  309. expectOperation( transOp[ 0 ], expected );
  310. } );
  311. } );
  312. describe( 'by NoOperation', () => {
  313. it( 'no operation update', () => {
  314. let transformBy = new NoOperation( baseVersion );
  315. let transOp = transform( op, transformBy );
  316. expect( transOp.length ).to.equal( 1 );
  317. expectOperation( transOp[ 0 ], expected );
  318. } );
  319. } );
  320. } );
  321. describe( 'AttributeOperation', () => {
  322. let start, end, range;
  323. beforeEach( () => {
  324. expected = {
  325. type: AttributeOperation,
  326. key: 'foo',
  327. oldValue: 'abc',
  328. newValue: 'bar',
  329. baseVersion: baseVersion + 1
  330. };
  331. } );
  332. describe( 'with multi-level range', () => {
  333. beforeEach( () => {
  334. start = new Position( root, [ 1, 2 ] );
  335. end = new Position( root, [ 2, 2, 4 ] );
  336. range = new Range( start, end );
  337. op = new AttributeOperation( range, 'foo', 'abc', 'bar', baseVersion );
  338. expected.range = new Range( start, end );
  339. } );
  340. describe( 'by InsertOperation', () => {
  341. it( 'target at different position: no operation update', () => {
  342. let transformBy = new InsertOperation(
  343. new Position( root, [ 3, 3, 2 ] ),
  344. [ nodeA, nodeB ],
  345. baseVersion
  346. );
  347. let transOp = transform( op, transformBy );
  348. expect( transOp.length ).to.equal( 1 );
  349. expectOperation( transOp[ 0 ], expected );
  350. } );
  351. it( 'target at offset before: increment offset', () => {
  352. let transformBy = new InsertOperation(
  353. new Position( root, [ 1, 1 ] ),
  354. [ nodeA, nodeB ],
  355. baseVersion
  356. );
  357. let transOp = transform( op, transformBy );
  358. expected.range.start.offset += 2;
  359. expect( transOp.length ).to.equal( 1 );
  360. expectOperation( transOp[ 0 ], expected );
  361. } );
  362. it( 'target at same offset: increment offset', () => {
  363. let transformBy = new InsertOperation(
  364. new Position( root, [ 1, 2 ] ),
  365. [ nodeA, nodeB ],
  366. baseVersion
  367. );
  368. let transOp = transform( op, transformBy );
  369. expected.range.start.offset += 2;
  370. expect( transOp.length ).to.equal( 1 );
  371. expectOperation( transOp[ 0 ], expected );
  372. } );
  373. it( 'target at offset after: no operation update', () => {
  374. let transformBy = new InsertOperation(
  375. new Position( root, [ 3, 2 ] ),
  376. [ nodeA, nodeB ],
  377. baseVersion
  378. );
  379. let transOp = transform( op, transformBy );
  380. expect( transOp.length ).to.equal( 1 );
  381. expectOperation( transOp[ 0 ], expected );
  382. } );
  383. it( 'target before node from path: increment index on path', () => {
  384. let transformBy = new InsertOperation(
  385. new Position( root, [ 0 ] ),
  386. [ nodeA, nodeB ],
  387. baseVersion
  388. );
  389. let transOp = transform( op, transformBy );
  390. expected.range.start.path[ 0 ] += 2;
  391. expected.range.end.path[ 0 ] += 2;
  392. expect( transOp.length ).to.equal( 1 );
  393. expectOperation( transOp[ 0 ], expected );
  394. } );
  395. it( 'target after node from path: no position change', () => {
  396. let transformBy = new InsertOperation(
  397. new Position( root, [ 2, 6 ] ),
  398. [ nodeA, nodeB ],
  399. baseVersion
  400. );
  401. let transOp = transform( op, transformBy );
  402. expect( transOp.length ).to.equal( 1 );
  403. expectOperation( transOp[ 0 ], expected );
  404. } );
  405. it( 'target inside change range: split into two operations', () => {
  406. let transformBy = new InsertOperation(
  407. new Position( root, [ 1, 3, 1 ] ),
  408. [ nodeA, nodeB ],
  409. baseVersion
  410. );
  411. let transOp = transform( op, transformBy );
  412. expect( transOp.length ).to.equal( 2 );
  413. expected.range.start.path = [ 1, 3, 3 ];
  414. expectOperation( transOp[ 0 ], expected );
  415. expected.range.start = op.range.start;
  416. expected.range.end.path = [ 1, 3, 1 ];
  417. expected.baseVersion++;
  418. expectOperation( transOp[ 1 ], expected );
  419. } );
  420. } );
  421. describe( 'by AttributeOperation', () => {
  422. it( 'attributes have different key: no operation update', () => {
  423. let transformBy = new AttributeOperation(
  424. Range.createFromRange( range ),
  425. 'abc',
  426. true,
  427. false,
  428. baseVersion
  429. );
  430. let transOp = transform( op, transformBy );
  431. expect( transOp.length ).to.equal( 1 );
  432. expectOperation( transOp[ 0 ], expected );
  433. } );
  434. it( 'same key and value: convert to NoOperation', () => {
  435. let transformBy = new AttributeOperation(
  436. Range.createFromRange( range ),
  437. 'foo',
  438. 'abc',
  439. 'bar',
  440. baseVersion
  441. );
  442. let transOp = transform( op, transformBy );
  443. expect( transOp.length ).to.equal( 1 );
  444. expectOperation( transOp[ 0 ], {
  445. type: NoOperation,
  446. baseVersion: baseVersion + 1
  447. } );
  448. } );
  449. it( 'both operations removes same attribute: convert to NoOperation', () => {
  450. op.newValue = null;
  451. let transformBy = new AttributeOperation(
  452. new Range( new Position( root, [ 1, 1, 4 ] ), new Position( root, [ 3 ] ) ),
  453. 'foo',
  454. 'another',
  455. null,
  456. baseVersion
  457. );
  458. let transOp = transform( op, transformBy, true );
  459. expected.newValue = null;
  460. expect( transOp.length ).to.equal( 1 );
  461. expectOperation( transOp[ 0 ], {
  462. type: NoOperation,
  463. baseVersion: baseVersion + 1
  464. } );
  465. } );
  466. describe( 'that is less important and', () => {
  467. it( 'range does not intersect original range: no operation update', () => {
  468. let transformBy = new AttributeOperation(
  469. new Range( new Position( root, [ 3, 0 ] ), new Position( root, [ 4 ] ) ),
  470. 'foo',
  471. 'another',
  472. null,
  473. baseVersion
  474. );
  475. let transOp = transform( op, transformBy, true );
  476. expect( transOp.length ).to.equal( 1 );
  477. expectOperation( transOp[ 0 ], expected );
  478. } );
  479. it( 'range contains original range: update oldValue', () => {
  480. let transformBy = new AttributeOperation(
  481. new Range( new Position( root, [ 1, 1, 4 ] ), new Position( root, [ 3 ] ) ),
  482. 'foo',
  483. 'another',
  484. null,
  485. baseVersion
  486. );
  487. let transOp = transform( op, transformBy, true );
  488. expected.oldValue = 'another';
  489. expect( transOp.length ).to.equal( 1 );
  490. expectOperation( transOp[ 0 ], expected );
  491. } );
  492. // [ original range < ] range transformed by >
  493. it( 'range intersects on left: split into two operations, update oldValue', () => {
  494. // Get more test cases and better code coverage
  495. op.newValue = null;
  496. let transformBy = new AttributeOperation(
  497. new Range( new Position( root, [ 1, 4, 2 ] ), new Position( root, [ 3 ] ) ),
  498. 'foo',
  499. 'another',
  500. // Get more test cases and better code coverage
  501. 'anothernew',
  502. baseVersion
  503. );
  504. let transOp = transform( op, transformBy, true );
  505. expect( transOp.length ).to.equal( 2 );
  506. expected.newValue = null;
  507. expected.range.end.path = [ 1, 4, 2 ];
  508. expectOperation( transOp[ 0 ], expected );
  509. expected.range.start.path = [ 1, 4, 2 ];
  510. expected.range.end = op.range.end;
  511. expected.oldValue = 'another';
  512. expected.baseVersion++;
  513. expectOperation( transOp[ 1 ], expected );
  514. } );
  515. // [ range transformed by < ] original range >
  516. it( 'range intersects on right: split into two operations, update oldValue', () => {
  517. let transformBy = new AttributeOperation(
  518. new Range( new Position( root, [ 1 ] ), new Position( root, [ 2, 1 ] ) ),
  519. 'foo',
  520. 'another',
  521. null,
  522. baseVersion
  523. );
  524. let transOp = transform( op, transformBy, true );
  525. expect( transOp.length ).to.equal( 2 );
  526. expected.range.start.path = [ 2, 1 ];
  527. expectOperation( transOp[ 0 ], expected );
  528. expected.range.start = op.range.start;
  529. expected.range.end.path = [ 2, 1 ];
  530. expected.oldValue = 'another';
  531. expected.baseVersion++;
  532. expectOperation( transOp[ 1 ], expected );
  533. } );
  534. it( 'range is inside original range: split into three operations, update oldValue', () => {
  535. let transformBy = new AttributeOperation(
  536. new Range( new Position( root, [ 1, 4, 1 ] ), new Position( root, [ 2, 1 ] ) ),
  537. 'foo',
  538. 'another',
  539. null,
  540. baseVersion
  541. );
  542. let transOp = transform( op, transformBy, true );
  543. expect( transOp.length ).to.equal( 3 );
  544. expected.range.end.path = [ 1, 4, 1 ];
  545. expectOperation( transOp[ 0 ], expected );
  546. expected.range.start.path = [ 2, 1 ];
  547. expected.range.end = op.range.end;
  548. expected.baseVersion++;
  549. expectOperation( transOp[ 1 ], expected );
  550. expected.range.start.path = [ 1, 4, 1 ];
  551. expected.range.end.path = [ 2, 1 ];
  552. expected.oldValue = 'another';
  553. expected.baseVersion++;
  554. expectOperation( transOp[ 2 ], expected );
  555. } );
  556. } );
  557. describe( 'that is more important and', () => {
  558. it( 'range does not intersect original range: no operation update', () => {
  559. let transformBy = new AttributeOperation(
  560. new Range( new Position( root, [ 3, 0 ] ), new Position( root, [ 4 ] ) ),
  561. 'foo',
  562. 'abc',
  563. null,
  564. baseVersion
  565. );
  566. let transOp = transform( op, transformBy );
  567. expect( transOp.length ).to.equal( 1 );
  568. expectOperation( transOp[ 0 ], expected );
  569. } );
  570. it( 'range contains original range: convert to NoOperation', () => {
  571. let transformBy = new AttributeOperation(
  572. new Range( new Position( root, [ 1, 1, 4 ] ), new Position( root, [ 3 ] ) ),
  573. 'foo',
  574. 'abc',
  575. null,
  576. baseVersion
  577. );
  578. let transOp = transform( op, transformBy );
  579. expect( transOp.length ).to.equal( 1 );
  580. expectOperation( transOp[ 0 ], {
  581. type: NoOperation,
  582. baseVersion: baseVersion + 1
  583. } );
  584. } );
  585. // [ original range < ] range transformed by >
  586. it( 'range intersects on left: shrink original range', () => {
  587. let transformBy = new AttributeOperation(
  588. new Range( new Position( root, [ 1, 4, 2 ] ), new Position( root, [ 3 ] ) ),
  589. 'foo',
  590. 'abc',
  591. null,
  592. baseVersion
  593. );
  594. let transOp = transform( op, transformBy );
  595. expected.range.end.path = [ 1, 4, 2 ];
  596. expect( transOp.length ).to.equal( 1 );
  597. expectOperation( transOp[ 0 ], expected );
  598. } );
  599. // [ range transformed by < ] original range >
  600. it( 'range intersects on right: shrink original range', () => {
  601. let transformBy = new AttributeOperation(
  602. new Range( new Position( root, [ 1 ] ), new Position( root, [ 2, 1 ] ) ),
  603. 'foo',
  604. 'abc',
  605. null,
  606. baseVersion
  607. );
  608. let transOp = transform( op, transformBy );
  609. expected.range.start.path = [ 2, 1 ];
  610. expect( transOp.length ).to.equal( 1 );
  611. expectOperation( transOp[ 0 ], expected );
  612. } );
  613. it( 'range is inside original range: split into two operations', () => {
  614. let transformBy = new AttributeOperation(
  615. new Range( new Position( root, [ 1, 4, 1 ] ), new Position( root, [ 2, 1 ] ) ),
  616. 'foo',
  617. 'abc',
  618. null,
  619. baseVersion
  620. );
  621. let transOp = transform( op, transformBy );
  622. expect( transOp.length ).to.equal( 2 );
  623. expected.range.end.path = [ 1, 4, 1 ];
  624. expectOperation( transOp[ 0 ], expected );
  625. expected.range.start.path = [ 2, 1 ];
  626. expected.range.end = op.range.end;
  627. expected.baseVersion++;
  628. expectOperation( transOp[ 1 ], expected );
  629. } );
  630. } );
  631. } );
  632. describe( 'by RootAttributeOperation', () => {
  633. it( 'no operation update', () => {
  634. let transformBy = new RootAttributeOperation(
  635. root,
  636. 'foo',
  637. null,
  638. 'bar',
  639. baseVersion
  640. );
  641. let transOp = transform( op, transformBy );
  642. expect( transOp.length ).to.equal( 1 );
  643. expectOperation( transOp[ 0 ], expected );
  644. } );
  645. } );
  646. describe( 'by MoveOperation', () => {
  647. it( 'range and target are different than change range: no operation update', () => {
  648. let transformBy = new MoveOperation(
  649. new Position( root, [ 1, 1, 2 ] ),
  650. 2,
  651. new Position( root, [ 3, 4 ] ),
  652. baseVersion
  653. );
  654. let transOp = transform( op, transformBy );
  655. expect( transOp.length ).to.equal( 1 );
  656. expectOperation( transOp[ 0 ], expected );
  657. } );
  658. it( 'range offset is before change range start offset: decrement offset', () => {
  659. let transformBy = new MoveOperation(
  660. new Position( root, [ 1, 0 ] ),
  661. 2,
  662. new Position( root, [ 3, 4, 1 ] ),
  663. baseVersion
  664. );
  665. let transOp = transform( op, transformBy );
  666. expected.range.start.offset -= 2;
  667. expect( transOp.length ).to.equal( 1 );
  668. expectOperation( transOp[ 0 ], expected );
  669. } );
  670. it( 'target offset is before change range start offset: increment offset', () => {
  671. let transformBy = new MoveOperation(
  672. new Position( root, [ 3, 4, 1 ] ),
  673. 2,
  674. new Position( root, [ 1, 0 ] ),
  675. baseVersion
  676. );
  677. let transOp = transform( op, transformBy );
  678. expected.range.start.offset += 2;
  679. expect( transOp.length ).to.equal( 1 );
  680. expectOperation( transOp[ 0 ], expected );
  681. } );
  682. it( 'range is before node from path to change range: decrement index on path', () => {
  683. let transformBy = new MoveOperation(
  684. new Position( root, [ 0 ] ),
  685. 1,
  686. new Position( root, [ 2, 4, 1 ] ),
  687. baseVersion
  688. );
  689. let transOp = transform( op, transformBy );
  690. expected.range.start.path[ 0 ]--;
  691. expected.range.end.path[ 0 ]--;
  692. expect( transOp.length ).to.equal( 1 );
  693. expectOperation( transOp[ 0 ], expected );
  694. } );
  695. it( 'range is after node from path to change range: no position change', () => {
  696. let transformBy = new MoveOperation(
  697. new Position( root, [ 3 ] ),
  698. 2,
  699. new Position( root, [ 0, 1 ] ),
  700. baseVersion
  701. );
  702. let transOp = transform( op, transformBy );
  703. expect( transOp.length ).to.equal( 1 );
  704. expectOperation( transOp[ 0 ], expected );
  705. } );
  706. it( 'target before node from path to change range: increment index on path', () => {
  707. let transformBy = new MoveOperation(
  708. new Position( root, [ 3, 4, 1 ] ),
  709. 2,
  710. new Position( root, [ 1, 0 ] ),
  711. baseVersion
  712. );
  713. let transOp = transform( op, transformBy );
  714. expected.range.start.path[ 1 ] += 2;
  715. expect( transOp.length ).to.equal( 1 );
  716. expectOperation( transOp[ 0 ], expected );
  717. } );
  718. it( 'target after node from path to change range: no position change', () => {
  719. let transformBy = new MoveOperation(
  720. new Position( root, [ 3, 4, 1 ] ),
  721. 2,
  722. new Position( root, [ 3 ] ),
  723. baseVersion
  724. );
  725. let transOp = transform( op, transformBy );
  726. expect( transOp.length ).to.equal( 1 );
  727. expectOperation( transOp[ 0 ], expected );
  728. } );
  729. it( 'range intersects on left with change range: split into two operations', () => {
  730. let transformBy = new MoveOperation(
  731. new Position( root, [ 2, 1 ] ),
  732. 3,
  733. new Position( root, [ 4 ] ),
  734. baseVersion
  735. );
  736. let transOp = transform( op, transformBy );
  737. expect( transOp.length ).to.equal( 2 );
  738. expected.range.end.path = [ 2, 1 ];
  739. expectOperation( transOp[ 0 ], expected );
  740. expected.range.start.path = [ 4 ];
  741. expected.range.end.path = [ 5, 4 ];
  742. expected.baseVersion++;
  743. expectOperation( transOp[ 1 ], expected );
  744. } );
  745. it( 'range intersects on right with change range: split into two operation', () => {
  746. let transformBy = new MoveOperation(
  747. new Position( root, [ 1, 1 ] ),
  748. 3,
  749. new Position( root, [ 0, 0 ] ),
  750. baseVersion
  751. );
  752. let transOp = transform( op, transformBy );
  753. expect( transOp.length ).to.equal( 2 );
  754. expected.range.start.path = [ 1, 1 ];
  755. expectOperation( transOp[ 0 ], expected );
  756. expected.range.start.path = [ 0, 1 ];
  757. expected.range.end.path = [ 0, 3 ];
  758. expected.baseVersion++;
  759. expectOperation( transOp[ 1 ], expected );
  760. } );
  761. it( 'range contains change range: update change range', () => {
  762. let transformBy = new MoveOperation(
  763. new Position( root, [ 1 ] ),
  764. 2,
  765. new Position( root, [ 3, 4, 1 ] ),
  766. baseVersion
  767. );
  768. let transOp = transform( op, transformBy );
  769. expected.range.start.path = [ 1, 4, 1, 2 ];
  770. expected.range.end.path = [ 1, 4, 2, 2, 4 ];
  771. expect( transOp.length ).to.equal( 1 );
  772. expectOperation( transOp[ 0 ], expected );
  773. } );
  774. it( 'range is inside change range: split into two operations', () => {
  775. let transformBy = new MoveOperation(
  776. new Position( root, [ 1, 4 ] ),
  777. 2,
  778. new Position( root, [ 3, 2 ] ),
  779. baseVersion
  780. );
  781. let transOp = transform( op, transformBy );
  782. expect( transOp.length ).to.equal( 2 );
  783. expectOperation( transOp[ 0 ], expected );
  784. expected.range.start.path = [ 3, 2 ];
  785. expected.range.end.path = [ 3, 4 ];
  786. expected.baseVersion++;
  787. expectOperation( transOp[ 1 ], expected );
  788. } );
  789. it( 'target inside change range: split into two operations', () => {
  790. let transformBy = new MoveOperation(
  791. new Position( root, [ 3, 4, 1 ] ),
  792. 2,
  793. new Position( root, [ 1, 4 ] ),
  794. baseVersion
  795. );
  796. let transOp = transform( op, transformBy );
  797. expect( transOp.length ).to.equal( 2 );
  798. expected.range.start.path = [ 1, 6 ];
  799. expectOperation( transOp[ 0 ], expected );
  800. expected.range.start = op.range.start;
  801. expected.range.end.path = [ 1, 4 ];
  802. expected.baseVersion++;
  803. expectOperation( transOp[ 1 ], expected );
  804. } );
  805. it( 'range intersects change range and target inside change range: split into three operations', () => {
  806. let transformBy = new MoveOperation(
  807. new Position( root, [ 1, 1 ] ),
  808. 3,
  809. new Position( root, [ 2 ] ),
  810. baseVersion
  811. );
  812. let transOp = transform( op, transformBy );
  813. expect( transOp.length ).to.equal( 3 );
  814. expected.range.start.path = [ 5 ];
  815. expected.range.end.path = [ 5, 2, 4 ];
  816. expectOperation( transOp[ 0 ], expected );
  817. expected.range.start.path = [ 1, 1 ];
  818. expected.range.end.path = [ 2 ];
  819. expected.baseVersion++;
  820. expectOperation( transOp[ 1 ], expected );
  821. expected.range.start.path = [ 3 ];
  822. expected.range.end.path = [ 5 ];
  823. expected.baseVersion++;
  824. expectOperation( transOp[ 2 ], expected );
  825. } );
  826. } );
  827. describe( 'by NoOperation', () => {
  828. it( 'no operation update', () => {
  829. let transformBy = new NoOperation( baseVersion );
  830. let transOp = transform( op, transformBy );
  831. expect( transOp.length ).to.equal( 1 );
  832. expectOperation( transOp[ 0 ], expected );
  833. } );
  834. } );
  835. } );
  836. // Some extra cases for a AttributeOperation that operates on single tree level range.
  837. // This means that the change range start and end differs only on offset value.
  838. // This test suite also have some modifications to the original operation
  839. // to get more test cases covered and better code coverage.
  840. describe( 'with single-level range', () => {
  841. beforeEach( () => {
  842. start = new Position( root, [ 0, 2, 1 ] );
  843. end = new Position( root, [ 0, 2, 4 ] );
  844. range = new Range( start, end );
  845. op = new AttributeOperation( range, 'foo', 'abc', 'bar', baseVersion );
  846. expected.range = new Range( start, end );
  847. } );
  848. describe( 'by InsertOperation', () => {
  849. it( 'target at offset before: increment offset', () => {
  850. let transformBy = new InsertOperation(
  851. new Position( root, [ 0, 2, 0 ] ),
  852. [ nodeA, nodeB ],
  853. baseVersion
  854. );
  855. let transOp = transform( op, transformBy );
  856. expected.range.start.offset += 2;
  857. expected.range.end.offset += 2;
  858. expect( transOp.length ).to.equal( 1 );
  859. expectOperation( transOp[ 0 ], expected );
  860. } );
  861. it( 'target at same offset: increment offset', () => {
  862. let transformBy = new InsertOperation(
  863. new Position( root, [ 0, 2, 1 ] ),
  864. [ nodeA, nodeB ],
  865. baseVersion
  866. );
  867. let transOp = transform( op, transformBy );
  868. expected.range.start.offset += 2;
  869. expected.range.end.offset += 2;
  870. expect( transOp.length ).to.equal( 1 );
  871. expectOperation( transOp[ 0 ], expected );
  872. } );
  873. } );
  874. describe( 'by MoveOperation', () => {
  875. it( 'range offset is before change range start offset: decrement offset', () => {
  876. let transformBy = new MoveOperation(
  877. new Position( root, [ 0, 2, 0 ] ),
  878. 1,
  879. new Position( root, [ 2, 4, 1 ] ),
  880. baseVersion
  881. );
  882. let transOp = transform( op, transformBy );
  883. expected.range.start.offset--;
  884. expected.range.end.offset--;
  885. expect( transOp.length ).to.equal( 1 );
  886. expectOperation( transOp[ 0 ], expected );
  887. } );
  888. it( 'target offset is before change range start offset: increment offset', () => {
  889. let transformBy = new MoveOperation(
  890. new Position( root, [ 2, 4, 1 ] ),
  891. 2,
  892. new Position( root, [ 0, 2, 0 ] ),
  893. baseVersion
  894. );
  895. let transOp = transform( op, transformBy );
  896. expected.range.start.offset += 2;
  897. expected.range.end.offset += 2;
  898. expect( transOp.length ).to.equal( 1 );
  899. expectOperation( transOp[ 0 ], expected );
  900. } );
  901. it( 'range intersects on left with change range: split into two operations', () => {
  902. let transformBy = new MoveOperation(
  903. new Position( root, [ 0, 2, 2 ] ),
  904. 4,
  905. new Position( root, [ 2, 4, 1 ] ),
  906. baseVersion
  907. );
  908. let transOp = transform( op, transformBy );
  909. expect( transOp.length ).to.equal( 2 );
  910. expected.range.end.offset -= 2;
  911. expectOperation( transOp[ 0 ], expected );
  912. expected.range.start.path = [ 2, 4, 1 ];
  913. expected.range.end.path = [ 2, 4, 3 ];
  914. expected.baseVersion++;
  915. expectOperation( transOp[ 1 ], expected );
  916. } );
  917. it( 'range intersects on right with change range: split into two operation', () => {
  918. let transformBy = new MoveOperation(
  919. new Position( root, [ 0, 2, 0 ] ),
  920. 2,
  921. new Position( root, [ 2, 4, 1 ] ),
  922. baseVersion
  923. );
  924. let transOp = transform( op, transformBy );
  925. expect( transOp.length ).to.equal( 2 );
  926. expected.range.start.offset -= 1;
  927. expected.range.end.offset -= 2;
  928. expectOperation( transOp[ 0 ], expected );
  929. expected.range.start.path = [ 2, 4, 2 ];
  930. expected.range.end.path = [ 2, 4, 3 ];
  931. expected.baseVersion++;
  932. expectOperation( transOp[ 1 ], expected );
  933. } );
  934. it( 'range contains change range: update change range', () => {
  935. let transformBy = new MoveOperation(
  936. new Position( root, [ 0, 1 ] ),
  937. 3,
  938. new Position( root, [ 2, 4, 1 ] ),
  939. baseVersion
  940. );
  941. let transOp = transform( op, transformBy );
  942. expected.range.start.path = [ 2, 4, 2, 1 ];
  943. expected.range.end.path = [ 2, 4, 2, 4 ];
  944. expect( transOp.length ).to.equal( 1 );
  945. expectOperation( transOp[ 0 ], expected );
  946. } );
  947. it( 'range is inside change range: split into two operations', () => {
  948. let transformBy = new MoveOperation(
  949. new Position( root, [ 0, 2, 2 ] ),
  950. 1,
  951. new Position( root, [ 2, 4, 1 ] ),
  952. baseVersion
  953. );
  954. let transOp = transform( op, transformBy );
  955. expect( transOp.length ).to.equal( 2 );
  956. expected.range.end.offset--;
  957. expectOperation( transOp[ 0 ], expected );
  958. expected.range.start.path = [ 2, 4, 1 ];
  959. expected.range.end.path = [ 2, 4, 2 ];
  960. expected.baseVersion++;
  961. expectOperation( transOp[ 1 ], expected );
  962. } );
  963. it( 'range is same as change range: update change range', () => {
  964. let transformBy = new MoveOperation(
  965. new Position( root, [ 0, 2, 1 ] ),
  966. 3,
  967. new Position( root, [ 2, 4, 1 ] ),
  968. baseVersion
  969. );
  970. let transOp = transform( op, transformBy );
  971. expected.range.start.path = [ 2, 4, 1 ];
  972. expected.range.end.path = [ 2, 4, 4 ];
  973. expect( transOp.length ).to.equal( 1 );
  974. expectOperation( transOp[ 0 ], expected );
  975. } );
  976. it( 'target inside change range: split into two operations', () => {
  977. let transformBy = new MoveOperation(
  978. new Position( root, [ 2, 4, 1 ] ),
  979. 2,
  980. new Position( root, [ 0, 2, 2 ] ),
  981. baseVersion
  982. );
  983. let transOp = transform( op, transformBy );
  984. expect( transOp.length ).to.equal( 2 );
  985. expected.range.start.offset = 4;
  986. expected.range.end.offset = 6;
  987. expectOperation( transOp[ 0 ], expected );
  988. expected.range.start.offset = op.range.start.offset;
  989. expected.range.end.offset = 2;
  990. expected.baseVersion++;
  991. expectOperation( transOp[ 1 ], expected );
  992. } );
  993. it( 'range intersects change range and target inside change range: split into three operations', () => {
  994. let transformBy = new MoveOperation(
  995. new Position( root, [ 0, 2, 0 ] ),
  996. 2,
  997. new Position( root, [ 0, 2, 3 ] ),
  998. baseVersion
  999. );
  1000. let transOp = transform( op, transformBy );
  1001. expect( transOp.length ).to.equal( 3 );
  1002. expected.range.start.offset = 3;
  1003. expected.range.end.offset = 4;
  1004. expectOperation( transOp[ 0 ], expected );
  1005. expected.range.start.offset = 0;
  1006. expected.range.end.offset = 1;
  1007. expected.baseVersion++;
  1008. expectOperation( transOp[ 1 ], expected );
  1009. expected.range.start.offset = 2;
  1010. expected.range.end.offset = 3;
  1011. expected.baseVersion++;
  1012. expectOperation( transOp[ 2 ], expected );
  1013. } );
  1014. } );
  1015. } );
  1016. } );
  1017. describe( 'RootAttributeOperation', () => {
  1018. let diffRoot = new RootElement( null );
  1019. beforeEach( () => {
  1020. expected = {
  1021. type: RootAttributeOperation,
  1022. key: 'foo',
  1023. oldValue: 'abc',
  1024. newValue: 'bar',
  1025. baseVersion: baseVersion + 1
  1026. };
  1027. op = new RootAttributeOperation( root, 'foo', 'abc', 'bar', baseVersion );
  1028. } );
  1029. describe( 'by InsertOperation', () => {
  1030. it( 'no operation update', () => {
  1031. let transformBy = new InsertOperation(
  1032. new Position( root, [ 0 ] ),
  1033. 'a',
  1034. baseVersion
  1035. );
  1036. let transOp = transform( op, transformBy );
  1037. expect( transOp.length ).to.equal( 1 );
  1038. expectOperation( transOp[ 0 ], expected );
  1039. } );
  1040. } );
  1041. describe( 'by AttributeOperation', () => {
  1042. it( 'no operation update', () => {
  1043. let transformBy = new AttributeOperation(
  1044. new Range(
  1045. new Position( root, [ 0 ] ),
  1046. new Position( root, [ 1 ] )
  1047. ),
  1048. 'foo',
  1049. 'bar',
  1050. 'xyz',
  1051. baseVersion
  1052. );
  1053. let transOp = transform( op, transformBy );
  1054. expect( transOp.length ).to.equal( 1 );
  1055. expectOperation( transOp[ 0 ], expected );
  1056. } );
  1057. } );
  1058. describe( 'by RootAttributeOperation', () => {
  1059. it( 'changes different root: no operation update', () => {
  1060. let transformBy = new RootAttributeOperation(
  1061. diffRoot,
  1062. 'foo',
  1063. 'abc',
  1064. 'xyz',
  1065. baseVersion
  1066. );
  1067. let transOp = transform( op, transformBy );
  1068. expect( transOp.length ).to.equal( 1 );
  1069. expectOperation( transOp[ 0 ], expected );
  1070. } );
  1071. it( 'changes different key: no operation update', () => {
  1072. let transformBy = new RootAttributeOperation(
  1073. root,
  1074. 'abc',
  1075. 'abc',
  1076. 'xyz',
  1077. baseVersion
  1078. );
  1079. let transOp = transform( op, transformBy );
  1080. expect( transOp.length ).to.equal( 1 );
  1081. expectOperation( transOp[ 0 ], expected );
  1082. } );
  1083. it( 'sets same value for same key: convert to NoOperation', () => {
  1084. let transformBy = new RootAttributeOperation(
  1085. root,
  1086. 'foo',
  1087. 'abc',
  1088. 'bar',
  1089. baseVersion
  1090. );
  1091. let transOp = transform( op, transformBy );
  1092. expect( transOp.length ).to.equal( 1 );
  1093. expectOperation( transOp[ 0 ], {
  1094. type: NoOperation,
  1095. baseVersion: baseVersion + 1
  1096. } );
  1097. } );
  1098. it( 'sets different value for same key on same root and is important: no operation update', () => {
  1099. let transformBy = new RootAttributeOperation(
  1100. root,
  1101. 'foo',
  1102. 'abc',
  1103. 'xyz',
  1104. baseVersion
  1105. );
  1106. let transOp = transform( op, transformBy );
  1107. expect( transOp.length ).to.equal( 1 );
  1108. expectOperation( transOp[ 0 ], {
  1109. type: NoOperation,
  1110. baseVersion: baseVersion + 1
  1111. } );
  1112. } );
  1113. it( 'sets different value for same key on same root and is less important: convert to NoOperation', () => {
  1114. let transformBy = new RootAttributeOperation(
  1115. root,
  1116. 'foo',
  1117. 'abc',
  1118. 'xyz',
  1119. baseVersion
  1120. );
  1121. let transOp = transform( op, transformBy, true );
  1122. expect( transOp.length ).to.equal( 1 );
  1123. expectOperation( transOp[ 0 ], expected );
  1124. } );
  1125. } );
  1126. describe( 'by MoveOperation', () => {
  1127. it( 'no operation update', () => {
  1128. let transformBy = new MoveOperation(
  1129. new Position( root, [ 0 ] ),
  1130. 2,
  1131. new Position( root, [ 1 ] ),
  1132. baseVersion
  1133. );
  1134. let transOp = transform( op, transformBy );
  1135. expect( transOp.length ).to.equal( 1 );
  1136. expectOperation( transOp[ 0 ], expected );
  1137. } );
  1138. } );
  1139. describe( 'by NoOperation', () => {
  1140. it( 'no operation update', () => {
  1141. let transformBy = new NoOperation( baseVersion );
  1142. let transOp = transform( op, transformBy );
  1143. expect( transOp.length ).to.equal( 1 );
  1144. expectOperation( transOp[ 0 ], expected );
  1145. } );
  1146. } );
  1147. } );
  1148. describe( 'MoveOperation', () => {
  1149. let sourcePosition, targetPosition, rangeEnd, howMany;
  1150. beforeEach( () => {
  1151. sourcePosition = new Position( root, [ 2, 2, 4 ] );
  1152. targetPosition = new Position( root, [ 3, 3, 3 ] );
  1153. howMany = 2;
  1154. rangeEnd = Position.createFromPosition( sourcePosition );
  1155. rangeEnd.offset += howMany;
  1156. op = new MoveOperation( sourcePosition, howMany, targetPosition, baseVersion );
  1157. expected = {
  1158. type: MoveOperation,
  1159. sourcePosition: Position.createFromPosition( sourcePosition ),
  1160. targetPosition: Position.createFromPosition( targetPosition ),
  1161. howMany: howMany,
  1162. baseVersion: baseVersion + 1
  1163. };
  1164. } );
  1165. describe( 'by InsertOperation', () => {
  1166. it( 'target at different position than move range and target: no operation update', () => {
  1167. let transformBy = new InsertOperation(
  1168. new Position( root, [ 1, 3, 2 ] ),
  1169. [ nodeA, nodeB ],
  1170. baseVersion
  1171. );
  1172. let transOp = transform( op, transformBy );
  1173. expect( transOp.length ).to.equal( 1 );
  1174. expectOperation( transOp[ 0 ], expected );
  1175. } );
  1176. it( 'target inside node from move range: no operation update', () => {
  1177. let transformBy = new InsertOperation(
  1178. new Position( root, [ 2, 2, 4, 1 ] ),
  1179. [ nodeA, nodeB ],
  1180. baseVersion
  1181. );
  1182. let transOp = transform( op, transformBy );
  1183. expect( transOp.length ).to.equal( 1 );
  1184. expectOperation( transOp[ 0 ], expected );
  1185. } );
  1186. it( 'target at offset before range offset: increment range offset', () => {
  1187. let transformBy = new InsertOperation(
  1188. new Position( root, [ 2, 2, 0 ] ),
  1189. [ nodeA, nodeB ],
  1190. baseVersion
  1191. );
  1192. let transOp = transform( op, transformBy );
  1193. expected.sourcePosition.offset += 2;
  1194. expect( transOp.length ).to.equal( 1 );
  1195. expectOperation( transOp[ 0 ], expected );
  1196. } );
  1197. it( 'target at offset after range offset: no operation update', () => {
  1198. let transformBy = new InsertOperation(
  1199. new Position( root, [ 2, 2, 7 ] ),
  1200. [ nodeA, nodeB ],
  1201. baseVersion
  1202. );
  1203. let transOp = transform( op, transformBy );
  1204. expect( transOp.length ).to.equal( 1 );
  1205. expectOperation( transOp[ 0 ], expected );
  1206. } );
  1207. it( 'target before node from range start path: increment index on range start path', () => {
  1208. let transformBy = new InsertOperation(
  1209. new Position( root, [ 2, 0 ] ),
  1210. [ nodeA, nodeB ],
  1211. baseVersion
  1212. );
  1213. let transOp = transform( op, transformBy );
  1214. expected.sourcePosition.path[ 1 ] += 2;
  1215. expect( transOp.length ).to.equal( 1 );
  1216. expectOperation( transOp[ 0 ], expected );
  1217. } );
  1218. it( 'target after node from range start path: no operation update', () => {
  1219. let transformBy = new InsertOperation(
  1220. new Position( root, [ 2, 3 ] ),
  1221. [ nodeA, nodeB ],
  1222. baseVersion
  1223. );
  1224. let transOp = transform( op, transformBy );
  1225. expect( transOp.length ).to.equal( 1 );
  1226. expectOperation( transOp[ 0 ], expected );
  1227. } );
  1228. it( 'target offset before move target offset: increment target offset', () => {
  1229. let transformBy = new InsertOperation(
  1230. new Position( root, [ 3, 3, 2 ] ),
  1231. [ nodeA, nodeB ],
  1232. baseVersion
  1233. );
  1234. let transOp = transform( op, transformBy );
  1235. expected.targetPosition.offset += 2;
  1236. expect( transOp.length ).to.equal( 1 );
  1237. expectOperation( transOp[ 0 ], expected );
  1238. } );
  1239. it( 'target offset after move target offset: no operation update', () => {
  1240. let transformBy = new InsertOperation(
  1241. new Position( root, [ 3, 3, 4 ] ),
  1242. [ nodeA, nodeB ],
  1243. baseVersion
  1244. );
  1245. let transOp = transform( op, transformBy );
  1246. expect( transOp.length ).to.equal( 1 );
  1247. expectOperation( transOp[ 0 ], expected );
  1248. } );
  1249. it( 'target before node from move target position path: increment index on move target position path', () => {
  1250. let transformBy = new InsertOperation(
  1251. new Position( root, [ 3, 0 ] ),
  1252. [ nodeA, nodeB ],
  1253. baseVersion
  1254. );
  1255. let transOp = transform( op, transformBy );
  1256. expected.targetPosition.path[ 1 ] += 2;
  1257. expect( transOp.length ).to.equal( 1 );
  1258. expectOperation( transOp[ 0 ], expected );
  1259. } );
  1260. it( 'target after node from move target position path: no operation update', () => {
  1261. let transformBy = new InsertOperation(
  1262. new Position( root, [ 3, 6 ] ),
  1263. [ nodeA, nodeB ],
  1264. baseVersion
  1265. );
  1266. let transOp = transform( op, transformBy );
  1267. expect( transOp.length ).to.equal( 1 );
  1268. expectOperation( transOp[ 0 ], expected );
  1269. } );
  1270. it( 'target offset same as move target offset and is important: increment target offset', () => {
  1271. let transformBy = new InsertOperation(
  1272. new Position( root, [ 3, 3, 3 ] ),
  1273. [ nodeA, nodeB ],
  1274. baseVersion
  1275. );
  1276. let transOp = transform( op, transformBy );
  1277. expected.targetPosition.offset += 2;
  1278. expect( transOp.length ).to.equal( 1 );
  1279. expectOperation( transOp[ 0 ], expected );
  1280. } );
  1281. it( 'target offset same as move target offset and is less important: no operation update', () => {
  1282. let transformBy = new InsertOperation(
  1283. new Position( root, [ 3, 3, 3 ] ),
  1284. [ nodeA, nodeB ],
  1285. baseVersion
  1286. );
  1287. let transOp = transform( op, transformBy, true );
  1288. expect( transOp.length ).to.equal( 1 );
  1289. expectOperation( transOp[ 0 ], expected );
  1290. } );
  1291. it( 'target offset same as move target offset: increment target offset', () => {
  1292. let transformBy = new InsertOperation(
  1293. new Position( root, [ 3, 3 ] ),
  1294. [ nodeA, nodeB ],
  1295. baseVersion
  1296. );
  1297. let transOp = transform( op, transformBy );
  1298. expected.targetPosition.path[ 1 ] += 2;
  1299. expect( transOp.length ).to.equal( 1 );
  1300. expectOperation( transOp[ 0 ], expected );
  1301. } );
  1302. it( 'target inside move range: expand range', () => {
  1303. let transformBy = new InsertOperation(
  1304. new Position( root, [ 2, 2, 5 ] ),
  1305. [ nodeA, nodeB ],
  1306. baseVersion
  1307. );
  1308. let transOp = transform( op, transformBy );
  1309. expect( transOp.length ).to.equal( 1 );
  1310. expected.howMany = 4;
  1311. expectOperation( transOp[ 0 ], expected );
  1312. } );
  1313. it( 'target at offset same as range end boundary: no operation update', () => {
  1314. let transformBy = new InsertOperation(
  1315. new Position( root, [ 2, 2, 6 ] ),
  1316. [ nodeA, nodeB ],
  1317. baseVersion
  1318. );
  1319. let transOp = transform( op, transformBy );
  1320. expect( transOp.length ).to.equal( 1 );
  1321. expectOperation( transOp[ 0 ], expected );
  1322. } );
  1323. it( 'target at offset same as range end boundary (sticky move): expand range', () => {
  1324. let transformBy = new InsertOperation(
  1325. new Position( root, [ 2, 2, 6 ] ),
  1326. [ nodeA, nodeB ],
  1327. baseVersion
  1328. );
  1329. op.isSticky = true;
  1330. let transOp = transform( op, transformBy );
  1331. expected.howMany = 4;
  1332. expect( transOp.length ).to.equal( 1 );
  1333. expectOperation( transOp[ 0 ], expected );
  1334. } );
  1335. } );
  1336. describe( 'by AttributeOperation', () => {
  1337. it( 'no operation update', () => {
  1338. let transformBy = new AttributeOperation(
  1339. new Range( sourcePosition, rangeEnd ),
  1340. 'abc',
  1341. true,
  1342. false,
  1343. baseVersion
  1344. );
  1345. let transOp = transform( op, transformBy );
  1346. expect( transOp.length ).to.equal( 1 );
  1347. expectOperation( transOp[ 0 ], expected );
  1348. } );
  1349. } );
  1350. describe( 'by RootAttributeOperation', () => {
  1351. it( 'no operation update', () => {
  1352. let transformBy = new RootAttributeOperation(
  1353. root,
  1354. 'foo',
  1355. null,
  1356. 'bar',
  1357. baseVersion
  1358. );
  1359. let transOp = transform( op, transformBy );
  1360. expect( transOp.length ).to.equal( 1 );
  1361. expectOperation( transOp[ 0 ], expected );
  1362. } );
  1363. } );
  1364. describe( 'by MoveOperation', () => {
  1365. it( 'range and target different than transforming range and target: no operation update', () => {
  1366. let transformBy = new MoveOperation(
  1367. new Position( root, [ 1, 2 ] ),
  1368. 3,
  1369. new Position( root, [ 4, 1, 0 ] ),
  1370. baseVersion
  1371. );
  1372. let transOp = transform( op, transformBy );
  1373. expect( transOp.length ).to.equal( 1 );
  1374. expectOperation( transOp[ 0 ], expected );
  1375. } );
  1376. it( 'target offset before transforming range start offset: increment range offset', () => {
  1377. let transformBy = new MoveOperation(
  1378. new Position( root, [ 4, 1, 0 ] ),
  1379. 2,
  1380. new Position( root, [ 2, 2, 0 ] ),
  1381. baseVersion
  1382. );
  1383. let transOp = transform( op, transformBy );
  1384. expected.sourcePosition.offset += 2;
  1385. expect( transOp.length ).to.equal( 1 );
  1386. expectOperation( transOp[ 0 ], expected );
  1387. } );
  1388. it( 'target offset after transforming range start offset: no operation update', () => {
  1389. let transformBy = new MoveOperation(
  1390. new Position( root, [ 4, 1, 0 ] ),
  1391. 2,
  1392. new Position( root, [ 2, 2, 7 ] ),
  1393. baseVersion
  1394. );
  1395. let transOp = transform( op, transformBy );
  1396. expect( transOp.length ).to.equal( 1 );
  1397. expectOperation( transOp[ 0 ], expected );
  1398. } );
  1399. it( 'range start offset before transforming range start offset: decrement range offset', () => {
  1400. let transformBy = new MoveOperation(
  1401. new Position( root, [ 2, 2, 0 ] ),
  1402. 2,
  1403. new Position( root, [ 4, 1, 0 ] ),
  1404. baseVersion
  1405. );
  1406. let transOp = transform( op, transformBy );
  1407. expected.sourcePosition.offset -= 2;
  1408. expect( transOp.length ).to.equal( 1 );
  1409. expectOperation( transOp[ 0 ], expected );
  1410. } );
  1411. it( 'range start offset after transforming range start offset: no operation update', () => {
  1412. let transformBy = new MoveOperation(
  1413. new Position( root, [ 2, 2, 9 ] ),
  1414. 2,
  1415. new Position( root, [ 4, 1, 0 ] ),
  1416. baseVersion
  1417. );
  1418. let transOp = transform( op, transformBy, true );
  1419. expect( transOp.length ).to.equal( 1 );
  1420. expectOperation( transOp[ 0 ], expected );
  1421. } );
  1422. it( 'target before node from transforming range start path: increment index on range start path', () => {
  1423. let transformBy = new MoveOperation(
  1424. new Position( root, [ 4, 1, 0 ] ),
  1425. 2,
  1426. new Position( root, [ 2, 1 ] ),
  1427. baseVersion
  1428. );
  1429. let transOp = transform( op, transformBy );
  1430. expected.sourcePosition.path[ 1 ] += 2;
  1431. expect( transOp.length ).to.equal( 1 );
  1432. expectOperation( transOp[ 0 ], expected );
  1433. } );
  1434. it( 'target after node from transforming range start path: no operation update', () => {
  1435. let transformBy = new MoveOperation(
  1436. new Position( root, [ 4, 1, 0 ] ),
  1437. 2,
  1438. new Position( root, [ 2, 5 ] ),
  1439. baseVersion
  1440. );
  1441. let transOp = transform( op, transformBy );
  1442. expect( transOp.length ).to.equal( 1 );
  1443. expectOperation( transOp[ 0 ], expected );
  1444. } );
  1445. it( 'range before node from transforming range start path: decrement index on range start path', () => {
  1446. let transformBy = new MoveOperation(
  1447. new Position( root, [ 2, 0 ] ),
  1448. 1,
  1449. new Position( root, [ 4, 1, 0 ] ),
  1450. baseVersion
  1451. );
  1452. let transOp = transform( op, transformBy );
  1453. expected.sourcePosition.path[ 1 ] -= 1;
  1454. expect( transOp.length ).to.equal( 1 );
  1455. expectOperation( transOp[ 0 ], expected );
  1456. } );
  1457. it( 'range after node from transforming range start path: no operation update', () => {
  1458. let transformBy = new MoveOperation(
  1459. new Position( root, [ 2, 3 ] ),
  1460. 2,
  1461. new Position( root, [ 4, 1, 0 ] ),
  1462. baseVersion
  1463. );
  1464. let transOp = transform( op, transformBy );
  1465. expect( transOp.length ).to.equal( 1 );
  1466. expectOperation( transOp[ 0 ], expected );
  1467. } );
  1468. it( 'target offset before transforming target offset: increment target offset', () => {
  1469. let transformBy = new MoveOperation(
  1470. new Position( root, [ 4, 1, 0 ] ),
  1471. 2,
  1472. new Position( root, [ 3, 3, 0 ] ),
  1473. baseVersion
  1474. );
  1475. let transOp = transform( op, transformBy );
  1476. expected.targetPosition.offset += 2;
  1477. expect( transOp.length ).to.equal( 1 );
  1478. expectOperation( transOp[ 0 ], expected );
  1479. } );
  1480. it( 'target offset after transforming target offset: no operation update', () => {
  1481. let transformBy = new MoveOperation(
  1482. new Position( root, [ 4, 1, 0 ] ),
  1483. 2,
  1484. new Position( root, [ 3, 3, 5 ] ),
  1485. baseVersion
  1486. );
  1487. let transOp = transform( op, transformBy );
  1488. expect( transOp.length ).to.equal( 1 );
  1489. expectOperation( transOp[ 0 ], expected );
  1490. } );
  1491. it( 'range offset before transforming target offset: decrement target offset', () => {
  1492. let transformBy = new MoveOperation(
  1493. new Position( root, [ 3, 3, 0 ] ),
  1494. 2,
  1495. new Position( root, [ 4, 1, 0 ] ),
  1496. baseVersion
  1497. );
  1498. let transOp = transform( op, transformBy );
  1499. expected.targetPosition.offset -= 2;
  1500. expect( transOp.length ).to.equal( 1 );
  1501. expectOperation( transOp[ 0 ], expected );
  1502. } );
  1503. it( 'range offset after transforming target offset: no operation update', () => {
  1504. let transformBy = new MoveOperation(
  1505. new Position( root, [ 3, 3, 5 ] ),
  1506. 2,
  1507. new Position( root, [ 4, 1, 0 ] ),
  1508. baseVersion
  1509. );
  1510. let transOp = transform( op, transformBy );
  1511. expect( transOp.length ).to.equal( 1 );
  1512. expectOperation( transOp[ 0 ], expected );
  1513. } );
  1514. it( 'target before node from transforming target path: increment index on target path', () => {
  1515. let transformBy = new MoveOperation(
  1516. new Position( root, [ 4, 1, 0 ] ),
  1517. 2,
  1518. new Position( root, [ 3, 1 ] ),
  1519. baseVersion
  1520. );
  1521. let transOp = transform( op, transformBy );
  1522. expected.targetPosition.path[ 1 ] += 2;
  1523. expect( transOp.length ).to.equal( 1 );
  1524. expectOperation( transOp[ 0 ], expected );
  1525. } );
  1526. it( 'target after node from transforming target path: no operation update', () => {
  1527. let transformBy = new MoveOperation(
  1528. new Position( root, [ 4, 1, 0 ] ),
  1529. 2,
  1530. new Position( root, [ 3, 5 ] ),
  1531. baseVersion
  1532. );
  1533. let transOp = transform( op, transformBy );
  1534. expect( transOp.length ).to.equal( 1 );
  1535. expectOperation( transOp[ 0 ], expected );
  1536. } );
  1537. it( 'range before node from transforming target path: decrement index on target path', () => {
  1538. let transformBy = new MoveOperation(
  1539. new Position( root, [ 3, 0 ] ),
  1540. 2,
  1541. new Position( root, [ 4, 1, 0 ] ),
  1542. baseVersion
  1543. );
  1544. let transOp = transform( op, transformBy );
  1545. expected.targetPosition.path[ 1 ] -= 2;
  1546. expect( transOp.length ).to.equal( 1 );
  1547. expectOperation( transOp[ 0 ], expected );
  1548. } );
  1549. it( 'range after node from transforming target path: no operation update', () => {
  1550. let transformBy = new MoveOperation(
  1551. new Position( root, [ 3, 5 ] ),
  1552. 2,
  1553. new Position( root, [ 4, 1, 0 ] ),
  1554. baseVersion
  1555. );
  1556. let transOp = transform( op, transformBy );
  1557. expect( transOp.length ).to.equal( 1 );
  1558. expectOperation( transOp[ 0 ], expected );
  1559. } );
  1560. it( 'target inside transforming move range: expand move range', () => {
  1561. let transformBy = new MoveOperation(
  1562. new Position( root, [ 4, 1, 0 ] ),
  1563. 2,
  1564. new Position( root, [ 2, 2, 5 ] ),
  1565. baseVersion
  1566. );
  1567. let transOp = transform( op, transformBy );
  1568. expect( transOp.length ).to.equal( 1 );
  1569. expected.howMany = 4;
  1570. expectOperation( transOp[ 0 ], expected );
  1571. } );
  1572. it( 'target at start boundary of transforming move range: increment source offset', () => {
  1573. let transformBy = new MoveOperation(
  1574. new Position( root, [ 4, 1, 0 ] ),
  1575. 2,
  1576. new Position( root, [ 2, 2, 4 ] ),
  1577. baseVersion
  1578. );
  1579. let transOp = transform( op, transformBy );
  1580. expect( transOp.length ).to.equal( 1 );
  1581. expected.sourcePosition.offset = 6;
  1582. expectOperation( transOp[ 0 ], expected );
  1583. } );
  1584. it( 'target at start boundary of transforming move range (sticky move): expand move range', () => {
  1585. let transformBy = new MoveOperation(
  1586. new Position( root, [ 4, 1, 0 ] ),
  1587. 2,
  1588. new Position( root, [ 2, 2, 4 ] ),
  1589. baseVersion
  1590. );
  1591. op.isSticky = true;
  1592. let transOp = transform( op, transformBy );
  1593. expect( transOp.length ).to.equal( 1 );
  1594. expected.howMany = 4;
  1595. expectOperation( transOp[ 0 ], expected );
  1596. } );
  1597. it( 'target at end boundary of transforming move range: no operation update', () => {
  1598. let transformBy = new MoveOperation(
  1599. new Position( root, [ 4, 1, 0 ] ),
  1600. 2,
  1601. new Position( root, [ 2, 2, 6 ] ),
  1602. baseVersion
  1603. );
  1604. let transOp = transform( op, transformBy );
  1605. expect( transOp.length ).to.equal( 1 );
  1606. expectOperation( transOp[ 0 ], expected );
  1607. } );
  1608. it( 'target at end boundary of transforming move range (sticky move): expand move range', () => {
  1609. let transformBy = new MoveOperation(
  1610. new Position( root, [ 4, 1, 0 ] ),
  1611. 2,
  1612. new Position( root, [ 2, 2, 6 ] ),
  1613. baseVersion
  1614. );
  1615. op.isSticky = true;
  1616. let transOp = transform( op, transformBy );
  1617. expect( transOp.length ).to.equal( 1 );
  1618. expected.howMany = 4;
  1619. expectOperation( transOp[ 0 ], expected );
  1620. } );
  1621. it( 'target inside a node from transforming range: no operation update', () => {
  1622. let transformBy = new MoveOperation(
  1623. new Position( root, [ 4, 1, 0 ] ),
  1624. 2,
  1625. new Position( root, [ 2, 2, 5, 1 ] ),
  1626. baseVersion
  1627. );
  1628. let transOp = transform( op, transformBy );
  1629. expect( transOp.length ).to.equal( 1 );
  1630. expectOperation( transOp[ 0 ], expected );
  1631. } );
  1632. it( 'range has node that contains transforming range: update range path', () => {
  1633. let transformBy = new MoveOperation(
  1634. new Position( root, [ 2, 1 ] ),
  1635. 3,
  1636. new Position( root, [ 4, 2 ] ),
  1637. baseVersion
  1638. );
  1639. let transOp = transform( op, transformBy );
  1640. expected.sourcePosition.path = [ 4, 3, 4 ];
  1641. expect( transOp.length ).to.equal( 1 );
  1642. expectOperation( transOp[ 0 ], expected );
  1643. } );
  1644. it( 'range has node that contains transforming target: update target path', () => {
  1645. let transformBy = new MoveOperation(
  1646. new Position( root, [ 3, 2 ] ),
  1647. 3,
  1648. new Position( root, [ 0, 1 ] ),
  1649. baseVersion
  1650. );
  1651. let transOp = transform( op, transformBy );
  1652. expected.targetPosition.path = [ 0, 2, 3 ];
  1653. expect( transOp.length ).to.equal( 1 );
  1654. expectOperation( transOp[ 0 ], expected );
  1655. } );
  1656. it( 'target inside a node from transforming range and vice versa: reverse transform-by operation', () => {
  1657. let transformBy = new MoveOperation(
  1658. new Position( root, [ 3, 2 ] ),
  1659. 3,
  1660. new Position( root, [ 2, 2, 5, 0 ] ),
  1661. baseVersion
  1662. );
  1663. let transOp = transform( op, transformBy );
  1664. let reversed = transformBy.getReversed();
  1665. expected.sourcePosition = reversed.sourcePosition;
  1666. expected.targetPosition = reversed.targetPosition;
  1667. expected.howMany = reversed.howMany;
  1668. expect( transOp.length ).to.equal( 1 );
  1669. expectOperation( transOp[ 0 ], expected );
  1670. } );
  1671. it( 'range is same as transforming range and is important: convert to NoOperation', () => {
  1672. let transformBy = new MoveOperation(
  1673. op.sourcePosition,
  1674. op.howMany,
  1675. new Position( root, [ 4, 1, 0 ] ),
  1676. baseVersion
  1677. );
  1678. let transOp = transform( op, transformBy );
  1679. expect( transOp.length ).to.equal( 1 );
  1680. expectOperation( transOp[ 0 ], {
  1681. type: NoOperation,
  1682. baseVersion: baseVersion + 1
  1683. } );
  1684. } );
  1685. it( 'range is same as transforming range and is less important: update range path', () => {
  1686. let transformBy = new MoveOperation(
  1687. op.sourcePosition,
  1688. op.howMany,
  1689. new Position( root, [ 4, 1, 0 ] ),
  1690. baseVersion
  1691. );
  1692. let transOp = transform( op, transformBy, true );
  1693. expected.sourcePosition.path = [ 4, 1, 0 ];
  1694. expect( transOp.length ).to.equal( 1 );
  1695. expectOperation( transOp[ 0 ], expected );
  1696. } );
  1697. it( 'range contains transforming range and is important: convert to NoOperation', () => {
  1698. let transformBy = new MoveOperation(
  1699. new Position( root, [ 2, 2, 3 ] ),
  1700. 4,
  1701. new Position( root, [ 4, 1, 0 ] ),
  1702. baseVersion
  1703. );
  1704. let transOp = transform( op, transformBy );
  1705. expect( transOp.length ).to.equal( 1 );
  1706. expectOperation( transOp[ 0 ], {
  1707. type: NoOperation,
  1708. baseVersion: baseVersion + 1
  1709. } );
  1710. } );
  1711. it( 'range contains transforming range and is less important: update range path', () => {
  1712. let transformBy = new MoveOperation(
  1713. new Position( root, [ 2, 2, 3 ] ),
  1714. 4,
  1715. new Position( root, [ 4, 1, 0 ] ),
  1716. baseVersion
  1717. );
  1718. let transOp = transform( op, transformBy, true );
  1719. expected.sourcePosition.path = [ 4, 1, 1 ];
  1720. expect( transOp.length ).to.equal( 1 );
  1721. expectOperation( transOp[ 0 ], expected );
  1722. } );
  1723. it( 'range contains transforming range and target and is important: update range path and target', () => {
  1724. op.targetPosition.path = [ 2, 2, 7 ];
  1725. let transformBy = new MoveOperation(
  1726. new Position( root, [ 2, 2, 3 ] ),
  1727. 5,
  1728. new Position( root, [ 4, 1, 0 ] ),
  1729. baseVersion
  1730. );
  1731. let transOp = transform( op, transformBy );
  1732. expect( transOp.length ).to.equal( 1 );
  1733. expected.sourcePosition.path = [ 4, 1, 1 ];
  1734. expected.targetPosition.path = [ 4, 1, 4 ];
  1735. expectOperation( transOp[ 0 ], expected );
  1736. } );
  1737. it( 'range contains transforming range and target and is less important: update range path and target', () => {
  1738. op.targetPosition.path = [ 2, 2, 7 ];
  1739. let transformBy = new MoveOperation(
  1740. new Position( root, [ 2, 2, 3 ] ),
  1741. 5,
  1742. new Position( root, [ 4, 1, 0 ] ),
  1743. baseVersion
  1744. );
  1745. let transOp = transform( op, transformBy, true );
  1746. expect( transOp.length ).to.equal( 1 );
  1747. expected.sourcePosition.path = [ 4, 1, 1 ];
  1748. expected.targetPosition.path = [ 4, 1, 4 ];
  1749. expectOperation( transOp[ 0 ], expected );
  1750. } );
  1751. it( 'range intersects on left side of transforming range and is important: shrink range', () => {
  1752. let transformBy = new MoveOperation(
  1753. new Position( root, [ 2, 2, 3 ] ),
  1754. 2,
  1755. new Position( root, [ 4, 1, 0 ] ),
  1756. baseVersion
  1757. );
  1758. let transOp = transform( op, transformBy );
  1759. expected.sourcePosition.path = [ 2, 2, 3 ];
  1760. expected.howMany = 1;
  1761. expect( transOp.length ).to.equal( 1 );
  1762. expectOperation( transOp[ 0 ], expected );
  1763. } );
  1764. it( 'range intersects on left side of transforming range and is less important: split into two operations', () => {
  1765. // Get more test cases and better code coverage
  1766. let otherRoot = new RootElement( null );
  1767. let transformBy = new MoveOperation(
  1768. new Position( root, [ 2, 2, 3 ] ),
  1769. 2,
  1770. new Position( otherRoot, [ 4, 1, 0 ] ),
  1771. baseVersion
  1772. );
  1773. let transOp = transform( op, transformBy, true );
  1774. expect( transOp.length ).to.equal( 2 );
  1775. expected.sourcePosition.path = [ 2, 2, 3 ];
  1776. expected.howMany = 1;
  1777. expectOperation( transOp[ 0 ], expected );
  1778. expected.sourcePosition = new Position( otherRoot, [ 4, 1, 1 ] );
  1779. expected.baseVersion++;
  1780. expectOperation( transOp[ 1 ], expected );
  1781. } );
  1782. it( 'range intersects on right side of transforming range and is important: shrink range', () => {
  1783. let transformBy = new MoveOperation(
  1784. new Position( root, [ 2, 2, 5 ] ),
  1785. 2,
  1786. new Position( root, [ 4, 1, 0 ] ),
  1787. baseVersion
  1788. );
  1789. let transOp = transform( op, transformBy );
  1790. expected.howMany = 1;
  1791. expect( transOp.length ).to.equal( 1 );
  1792. expectOperation( transOp[ 0 ], expected );
  1793. } );
  1794. it( 'range intersects on right side of transforming range and is less important: split into two operations', () => {
  1795. let transformBy = new MoveOperation(
  1796. new Position( root, [ 2, 2, 5 ] ),
  1797. 2,
  1798. new Position( root, [ 4, 1, 0 ] ),
  1799. baseVersion
  1800. );
  1801. let transOp = transform( op, transformBy, true );
  1802. expect( transOp.length ).to.equal( 2 );
  1803. expected.sourcePosition.path = [ 4, 1, 0 ];
  1804. expected.howMany = 1;
  1805. expectOperation( transOp[ 0 ], expected );
  1806. expected.sourcePosition.path = op.sourcePosition.path;
  1807. expected.baseVersion++;
  1808. expectOperation( transOp[ 1 ], expected );
  1809. } );
  1810. it( 'range intersects on left side, target inside transforming range and is important: expand move range', () => {
  1811. op.howMany = 4;
  1812. let transformBy = new MoveOperation(
  1813. new Position( root, [ 2, 2, 3 ] ),
  1814. 2,
  1815. new Position( root, [ 2, 2, 6 ] ),
  1816. baseVersion
  1817. );
  1818. let transOp = transform( op, transformBy );
  1819. expect( transOp.length ).to.equal( 1 );
  1820. expected.sourcePosition.path = [ 2, 2, 3 ];
  1821. expected.howMany = 5;
  1822. expectOperation( transOp[ 0 ], expected );
  1823. } );
  1824. it( 'range intersects on left side, target inside transforming range and is less important: expand move range', () => {
  1825. op.howMany = 4;
  1826. let transformBy = new MoveOperation(
  1827. new Position( root, [ 2, 2, 3 ] ),
  1828. 2,
  1829. new Position( root, [ 2, 2, 6 ] ),
  1830. baseVersion
  1831. );
  1832. let transOp = transform( op, transformBy, true );
  1833. expect( transOp.length ).to.equal( 1 );
  1834. expected.sourcePosition.path = [ 2, 2, 3 ];
  1835. expected.howMany = 5;
  1836. expectOperation( transOp[ 0 ], expected );
  1837. } );
  1838. it( 'range intersects on right side of transforming range and is important: shrink range', () => {
  1839. let transformBy = new MoveOperation(
  1840. new Position( root, [ 2, 2, 5 ] ),
  1841. 2,
  1842. new Position( root, [ 4, 1, 0 ] ),
  1843. baseVersion
  1844. );
  1845. let transOp = transform( op, transformBy );
  1846. expected.howMany = 1;
  1847. expect( transOp.length ).to.equal( 1 );
  1848. expectOperation( transOp[ 0 ], expected );
  1849. } );
  1850. it( 'range intersects on right side of transforming range and is less important: split into two operations', () => {
  1851. let transformBy = new MoveOperation(
  1852. new Position( root, [ 2, 2, 5 ] ),
  1853. 2,
  1854. new Position( root, [ 4, 1, 0 ] ),
  1855. baseVersion
  1856. );
  1857. let transOp = transform( op, transformBy, true );
  1858. expect( transOp.length ).to.equal( 2 );
  1859. expected.sourcePosition.path = [ 4, 1, 0 ];
  1860. expected.howMany = 1;
  1861. expectOperation( transOp[ 0 ], expected );
  1862. expected.sourcePosition.path = op.sourcePosition.path;
  1863. expected.baseVersion++;
  1864. expectOperation( transOp[ 1 ], expected );
  1865. } );
  1866. it( 'range intersects, target inside transforming range and is important: split into two operations', () => {
  1867. op.targetPosition.path = [ 2, 2, 7 ];
  1868. let transformBy = new MoveOperation(
  1869. new Position( root, [ 2, 2, 5 ] ),
  1870. 4,
  1871. new Position( root, [ 4, 1, 0 ] ),
  1872. baseVersion
  1873. );
  1874. let transOp = transform( op, transformBy, true );
  1875. expect( transOp.length ).to.equal( 2 );
  1876. expected.sourcePosition.path = [ 4, 1, 0 ];
  1877. expected.targetPosition.path = [ 4, 1, 2 ];
  1878. expected.howMany = 1;
  1879. expectOperation( transOp[ 0 ], expected );
  1880. expected.sourcePosition.path = [ 2, 2, 4 ];
  1881. expected.targetPosition.path = [ 4, 1, 2 ];
  1882. expected.howMany = 1;
  1883. expected.baseVersion++;
  1884. expectOperation( transOp[ 1 ], expected );
  1885. } );
  1886. it( 'range intersects, target inside transforming range and is less important: shrink range', () => {
  1887. op.targetPosition.path = [ 2, 2, 7 ];
  1888. let transformBy = new MoveOperation(
  1889. new Position( root, [ 2, 2, 5 ] ),
  1890. 4,
  1891. new Position( root, [ 4, 1, 0 ] ),
  1892. baseVersion
  1893. );
  1894. let transOp = transform( op, transformBy );
  1895. expect( transOp.length ).to.equal( 1 );
  1896. expected.sourcePosition.path = [ 2, 2, 4 ];
  1897. expected.targetPosition.path = [ 4, 1, 2 ];
  1898. expected.howMany = 1;
  1899. expectOperation( transOp[ 0 ], expected );
  1900. } );
  1901. it( 'range inside transforming range and is important: shrink range', () => {
  1902. op.howMany = 4;
  1903. let transformBy = new MoveOperation(
  1904. new Position( root, [ 2, 2, 5 ] ),
  1905. 2,
  1906. new Position( root, [ 4, 1, 0 ] ),
  1907. baseVersion
  1908. );
  1909. let transOp = transform( op, transformBy );
  1910. expect( transOp.length ).to.equal( 1 );
  1911. expected.howMany = 2;
  1912. expectOperation( transOp[ 0 ], expected );
  1913. } );
  1914. it( 'range inside transforming range and is less important: split into two operations', () => {
  1915. op.howMany = 4;
  1916. let transformBy = new MoveOperation(
  1917. new Position( root, [ 2, 2, 5 ] ),
  1918. 2,
  1919. new Position( root, [ 4, 1, 0 ] ),
  1920. baseVersion
  1921. );
  1922. let transOp = transform( op, transformBy, true );
  1923. expect( transOp.length ).to.equal( 2 );
  1924. expected.sourcePosition.path = [ 4, 1, 0 ];
  1925. expected.howMany = 2;
  1926. expectOperation( transOp[ 0 ], expected );
  1927. expected.sourcePosition.path = [ 2, 2, 4 ];
  1928. expected.howMany = 2;
  1929. expected.baseVersion++;
  1930. expectOperation( transOp[ 1 ], expected );
  1931. } );
  1932. it( 'range and target inside transforming range and is important: no operation update', () => {
  1933. op.howMany = 6;
  1934. let transformBy = new MoveOperation(
  1935. new Position( root, [ 2, 2, 5 ] ),
  1936. 2,
  1937. new Position( root, [ 2, 2, 9 ] ),
  1938. baseVersion
  1939. );
  1940. let transOp = transform( op, transformBy );
  1941. expect( transOp.length ).to.equal( 1 );
  1942. expected.howMany = 6;
  1943. expectOperation( transOp[ 0 ], expected );
  1944. } );
  1945. it( 'range and target inside transforming range and is less important: no operation update', () => {
  1946. op.howMany = 6;
  1947. let transformBy = new MoveOperation(
  1948. new Position( root, [ 2, 2, 5 ] ),
  1949. 2,
  1950. new Position( root, [ 2, 2, 9 ] ),
  1951. baseVersion
  1952. );
  1953. let transOp = transform( op, transformBy, true );
  1954. expect( transOp.length ).to.equal( 1 );
  1955. expected.howMany = 6;
  1956. expectOperation( transOp[ 0 ], expected );
  1957. } );
  1958. } );
  1959. describe( 'by NoOperation', () => {
  1960. it( 'no operation update', () => {
  1961. let transformBy = new NoOperation( baseVersion );
  1962. let transOp = transform( op, transformBy );
  1963. expect( transOp.length ).to.equal( 1 );
  1964. expectOperation( transOp[ 0 ], expected );
  1965. } );
  1966. } );
  1967. } );
  1968. describe( 'NoOperation', () => {
  1969. beforeEach( () => {
  1970. op = new NoOperation( baseVersion );
  1971. expected = {
  1972. type: NoOperation,
  1973. baseVersion: baseVersion + 1
  1974. };
  1975. } );
  1976. describe( 'by InsertOperation', () => {
  1977. it( 'no operation update', () => {
  1978. let transformBy = new InsertOperation(
  1979. new Position( root, [ 0 ] ),
  1980. 'a',
  1981. baseVersion
  1982. );
  1983. let transOp = transform( op, transformBy );
  1984. expect( transOp.length ).to.equal( 1 );
  1985. expectOperation( transOp[ 0 ], expected );
  1986. } );
  1987. } );
  1988. describe( 'by AttributeOperation', () => {
  1989. it( 'no operation update', () => {
  1990. let transformBy = new AttributeOperation(
  1991. new Range(
  1992. new Position( root, [ 0 ] ),
  1993. new Position( root, [ 1 ] )
  1994. ),
  1995. 'foo',
  1996. 'bar',
  1997. 'xyz',
  1998. baseVersion
  1999. );
  2000. let transOp = transform( op, transformBy );
  2001. expect( transOp.length ).to.equal( 1 );
  2002. expectOperation( transOp[ 0 ], expected );
  2003. } );
  2004. } );
  2005. describe( 'by RootAttributeOperation', () => {
  2006. it( 'no operation update', () => {
  2007. let transformBy = new RootAttributeOperation(
  2008. root,
  2009. 'foo',
  2010. null,
  2011. 'bar',
  2012. baseVersion
  2013. );
  2014. let transOp = transform( op, transformBy );
  2015. expect( transOp.length ).to.equal( 1 );
  2016. expectOperation( transOp[ 0 ], expected );
  2017. } );
  2018. } );
  2019. describe( 'by MoveOperation', () => {
  2020. it( 'no operation update', () => {
  2021. let transformBy = new MoveOperation(
  2022. new Position( root, [ 0 ] ),
  2023. 2,
  2024. new Position( root, [ 1 ] ),
  2025. baseVersion
  2026. );
  2027. let transOp = transform( op, transformBy );
  2028. expect( transOp.length ).to.equal( 1 );
  2029. expectOperation( transOp[ 0 ], expected );
  2030. } );
  2031. } );
  2032. describe( 'by NoOperation', () => {
  2033. it( 'no operation update', () => {
  2034. let transformBy = new NoOperation( baseVersion );
  2035. let transOp = transform( op, transformBy );
  2036. expect( transOp.length ).to.equal( 1 );
  2037. expectOperation( transOp[ 0 ], expected );
  2038. } );
  2039. } );
  2040. } );
  2041. } );