transform.js 69 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638
  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: expand range', () => {
  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. expected.howMany = 4;
  1321. expect( transOp.length ).to.equal( 1 );
  1322. expectOperation( transOp[ 0 ], expected );
  1323. } );
  1324. } );
  1325. describe( 'by AttributeOperation', () => {
  1326. it( 'no operation update', () => {
  1327. let transformBy = new AttributeOperation(
  1328. new Range( sourcePosition, rangeEnd ),
  1329. 'abc',
  1330. true,
  1331. false,
  1332. baseVersion
  1333. );
  1334. let transOp = transform( op, transformBy );
  1335. expect( transOp.length ).to.equal( 1 );
  1336. expectOperation( transOp[ 0 ], expected );
  1337. } );
  1338. } );
  1339. describe( 'by RootAttributeOperation', () => {
  1340. it( 'no operation update', () => {
  1341. let transformBy = new RootAttributeOperation(
  1342. root,
  1343. 'foo',
  1344. null,
  1345. 'bar',
  1346. baseVersion
  1347. );
  1348. let transOp = transform( op, transformBy );
  1349. expect( transOp.length ).to.equal( 1 );
  1350. expectOperation( transOp[ 0 ], expected );
  1351. } );
  1352. } );
  1353. describe( 'by MoveOperation', () => {
  1354. it( 'range and target different than transforming range and target: no operation update', () => {
  1355. let transformBy = new MoveOperation(
  1356. new Position( root, [ 1, 2 ] ),
  1357. 3,
  1358. new Position( root, [ 4, 1, 0 ] ),
  1359. baseVersion
  1360. );
  1361. let transOp = transform( op, transformBy );
  1362. expect( transOp.length ).to.equal( 1 );
  1363. expectOperation( transOp[ 0 ], expected );
  1364. } );
  1365. it( 'target offset before transforming range start offset: increment range offset', () => {
  1366. let transformBy = new MoveOperation(
  1367. new Position( root, [ 4, 1, 0 ] ),
  1368. 2,
  1369. new Position( root, [ 2, 2, 0 ] ),
  1370. baseVersion
  1371. );
  1372. let transOp = transform( op, transformBy );
  1373. expected.sourcePosition.offset += 2;
  1374. expect( transOp.length ).to.equal( 1 );
  1375. expectOperation( transOp[ 0 ], expected );
  1376. } );
  1377. it( 'target offset after transforming range start offset: no operation update', () => {
  1378. let transformBy = new MoveOperation(
  1379. new Position( root, [ 4, 1, 0 ] ),
  1380. 2,
  1381. new Position( root, [ 2, 2, 7 ] ),
  1382. baseVersion
  1383. );
  1384. let transOp = transform( op, transformBy );
  1385. expect( transOp.length ).to.equal( 1 );
  1386. expectOperation( transOp[ 0 ], expected );
  1387. } );
  1388. it( 'range start offset before transforming range start offset: decrement range offset', () => {
  1389. let transformBy = new MoveOperation(
  1390. new Position( root, [ 2, 2, 0 ] ),
  1391. 2,
  1392. new Position( root, [ 4, 1, 0 ] ),
  1393. baseVersion
  1394. );
  1395. let transOp = transform( op, transformBy );
  1396. expected.sourcePosition.offset -= 2;
  1397. expect( transOp.length ).to.equal( 1 );
  1398. expectOperation( transOp[ 0 ], expected );
  1399. } );
  1400. it( 'range start offset after transforming range start offset: no operation update', () => {
  1401. let transformBy = new MoveOperation(
  1402. new Position( root, [ 2, 2, 9 ] ),
  1403. 2,
  1404. new Position( root, [ 4, 1, 0 ] ),
  1405. baseVersion
  1406. );
  1407. let transOp = transform( op, transformBy, true );
  1408. expect( transOp.length ).to.equal( 1 );
  1409. expectOperation( transOp[ 0 ], expected );
  1410. } );
  1411. it( 'target before node from transforming range start path: increment index on range start path', () => {
  1412. let transformBy = new MoveOperation(
  1413. new Position( root, [ 4, 1, 0 ] ),
  1414. 2,
  1415. new Position( root, [ 2, 1 ] ),
  1416. baseVersion
  1417. );
  1418. let transOp = transform( op, transformBy );
  1419. expected.sourcePosition.path[ 1 ] += 2;
  1420. expect( transOp.length ).to.equal( 1 );
  1421. expectOperation( transOp[ 0 ], expected );
  1422. } );
  1423. it( 'target after node from transforming range start path: no operation update', () => {
  1424. let transformBy = new MoveOperation(
  1425. new Position( root, [ 4, 1, 0 ] ),
  1426. 2,
  1427. new Position( root, [ 2, 5 ] ),
  1428. baseVersion
  1429. );
  1430. let transOp = transform( op, transformBy );
  1431. expect( transOp.length ).to.equal( 1 );
  1432. expectOperation( transOp[ 0 ], expected );
  1433. } );
  1434. it( 'range before node from transforming range start path: decrement index on range start path', () => {
  1435. let transformBy = new MoveOperation(
  1436. new Position( root, [ 2, 0 ] ),
  1437. 1,
  1438. new Position( root, [ 4, 1, 0 ] ),
  1439. baseVersion
  1440. );
  1441. let transOp = transform( op, transformBy );
  1442. expected.sourcePosition.path[ 1 ] -= 1;
  1443. expect( transOp.length ).to.equal( 1 );
  1444. expectOperation( transOp[ 0 ], expected );
  1445. } );
  1446. it( 'range after node from transforming range start path: no operation update', () => {
  1447. let transformBy = new MoveOperation(
  1448. new Position( root, [ 2, 3 ] ),
  1449. 2,
  1450. new Position( root, [ 4, 1, 0 ] ),
  1451. baseVersion
  1452. );
  1453. let transOp = transform( op, transformBy );
  1454. expect( transOp.length ).to.equal( 1 );
  1455. expectOperation( transOp[ 0 ], expected );
  1456. } );
  1457. it( 'target offset before transforming target offset: increment target offset', () => {
  1458. let transformBy = new MoveOperation(
  1459. new Position( root, [ 4, 1, 0 ] ),
  1460. 2,
  1461. new Position( root, [ 3, 3, 0 ] ),
  1462. baseVersion
  1463. );
  1464. let transOp = transform( op, transformBy );
  1465. expected.targetPosition.offset += 2;
  1466. expect( transOp.length ).to.equal( 1 );
  1467. expectOperation( transOp[ 0 ], expected );
  1468. } );
  1469. it( 'target offset after transforming target offset: no operation update', () => {
  1470. let transformBy = new MoveOperation(
  1471. new Position( root, [ 4, 1, 0 ] ),
  1472. 2,
  1473. new Position( root, [ 3, 3, 5 ] ),
  1474. baseVersion
  1475. );
  1476. let transOp = transform( op, transformBy );
  1477. expect( transOp.length ).to.equal( 1 );
  1478. expectOperation( transOp[ 0 ], expected );
  1479. } );
  1480. it( 'range offset before transforming target offset: decrement target offset', () => {
  1481. let transformBy = new MoveOperation(
  1482. new Position( root, [ 3, 3, 0 ] ),
  1483. 2,
  1484. new Position( root, [ 4, 1, 0 ] ),
  1485. baseVersion
  1486. );
  1487. let transOp = transform( op, transformBy );
  1488. expected.targetPosition.offset -= 2;
  1489. expect( transOp.length ).to.equal( 1 );
  1490. expectOperation( transOp[ 0 ], expected );
  1491. } );
  1492. it( 'range offset after transforming target offset: no operation update', () => {
  1493. let transformBy = new MoveOperation(
  1494. new Position( root, [ 3, 3, 5 ] ),
  1495. 2,
  1496. new Position( root, [ 4, 1, 0 ] ),
  1497. baseVersion
  1498. );
  1499. let transOp = transform( op, transformBy );
  1500. expect( transOp.length ).to.equal( 1 );
  1501. expectOperation( transOp[ 0 ], expected );
  1502. } );
  1503. it( 'target before node from transforming target path: increment index on target path', () => {
  1504. let transformBy = new MoveOperation(
  1505. new Position( root, [ 4, 1, 0 ] ),
  1506. 2,
  1507. new Position( root, [ 3, 1 ] ),
  1508. baseVersion
  1509. );
  1510. let transOp = transform( op, transformBy );
  1511. expected.targetPosition.path[ 1 ] += 2;
  1512. expect( transOp.length ).to.equal( 1 );
  1513. expectOperation( transOp[ 0 ], expected );
  1514. } );
  1515. it( 'target after node from transforming target path: no operation update', () => {
  1516. let transformBy = new MoveOperation(
  1517. new Position( root, [ 4, 1, 0 ] ),
  1518. 2,
  1519. new Position( root, [ 3, 5 ] ),
  1520. baseVersion
  1521. );
  1522. let transOp = transform( op, transformBy );
  1523. expect( transOp.length ).to.equal( 1 );
  1524. expectOperation( transOp[ 0 ], expected );
  1525. } );
  1526. it( 'range before node from transforming target path: decrement index on target path', () => {
  1527. let transformBy = new MoveOperation(
  1528. new Position( root, [ 3, 0 ] ),
  1529. 2,
  1530. new Position( root, [ 4, 1, 0 ] ),
  1531. baseVersion
  1532. );
  1533. let transOp = transform( op, transformBy );
  1534. expected.targetPosition.path[ 1 ] -= 2;
  1535. expect( transOp.length ).to.equal( 1 );
  1536. expectOperation( transOp[ 0 ], expected );
  1537. } );
  1538. it( 'range after node from transforming target path: no operation update', () => {
  1539. let transformBy = new MoveOperation(
  1540. new Position( root, [ 3, 5 ] ),
  1541. 2,
  1542. new Position( root, [ 4, 1, 0 ] ),
  1543. baseVersion
  1544. );
  1545. let transOp = transform( op, transformBy );
  1546. expect( transOp.length ).to.equal( 1 );
  1547. expectOperation( transOp[ 0 ], expected );
  1548. } );
  1549. it( 'target inside transforming move range: expand move range', () => {
  1550. let transformBy = new MoveOperation(
  1551. new Position( root, [ 4, 1, 0 ] ),
  1552. 2,
  1553. new Position( root, [ 2, 2, 5 ] ),
  1554. baseVersion
  1555. );
  1556. let transOp = transform( op, transformBy );
  1557. expect( transOp.length ).to.equal( 1 );
  1558. expected.howMany = 4;
  1559. expectOperation( transOp[ 0 ], expected );
  1560. } );
  1561. it( 'target at start boundary of transforming move range: expand move range', () => {
  1562. let transformBy = new MoveOperation(
  1563. new Position( root, [ 4, 1, 0 ] ),
  1564. 2,
  1565. new Position( root, [ 2, 2, 4 ] ),
  1566. baseVersion
  1567. );
  1568. let transOp = transform( op, transformBy );
  1569. expect( transOp.length ).to.equal( 1 );
  1570. expected.howMany = 4;
  1571. expectOperation( transOp[ 0 ], expected );
  1572. } );
  1573. it( 'target at end boundary of transforming move range: expand move range', () => {
  1574. let transformBy = new MoveOperation(
  1575. new Position( root, [ 4, 1, 0 ] ),
  1576. 2,
  1577. new Position( root, [ 2, 2, 6 ] ),
  1578. baseVersion
  1579. );
  1580. let transOp = transform( op, transformBy );
  1581. expect( transOp.length ).to.equal( 1 );
  1582. expected.howMany = 4;
  1583. expectOperation( transOp[ 0 ], expected );
  1584. } );
  1585. it( 'target inside a node from transforming range: no operation update', () => {
  1586. let transformBy = new MoveOperation(
  1587. new Position( root, [ 4, 1, 0 ] ),
  1588. 2,
  1589. new Position( root, [ 2, 2, 5, 1 ] ),
  1590. baseVersion
  1591. );
  1592. let transOp = transform( op, transformBy );
  1593. expect( transOp.length ).to.equal( 1 );
  1594. expectOperation( transOp[ 0 ], expected );
  1595. } );
  1596. it( 'range has node that contains transforming range: update range path', () => {
  1597. let transformBy = new MoveOperation(
  1598. new Position( root, [ 2, 1 ] ),
  1599. 3,
  1600. new Position( root, [ 4, 2 ] ),
  1601. baseVersion
  1602. );
  1603. let transOp = transform( op, transformBy );
  1604. expected.sourcePosition.path = [ 4, 3, 4 ];
  1605. expect( transOp.length ).to.equal( 1 );
  1606. expectOperation( transOp[ 0 ], expected );
  1607. } );
  1608. it( 'range has node that contains transforming target: update target path', () => {
  1609. let transformBy = new MoveOperation(
  1610. new Position( root, [ 3, 2 ] ),
  1611. 3,
  1612. new Position( root, [ 0, 1 ] ),
  1613. baseVersion
  1614. );
  1615. let transOp = transform( op, transformBy );
  1616. expected.targetPosition.path = [ 0, 2, 3 ];
  1617. expect( transOp.length ).to.equal( 1 );
  1618. expectOperation( transOp[ 0 ], expected );
  1619. } );
  1620. it( 'target inside a node from transforming range and vice versa: reverse transform-by operation', () => {
  1621. let transformBy = new MoveOperation(
  1622. new Position( root, [ 3, 2 ] ),
  1623. 3,
  1624. new Position( root, [ 2, 2, 5, 0 ] ),
  1625. baseVersion
  1626. );
  1627. let transOp = transform( op, transformBy );
  1628. let reversed = transformBy.getReversed();
  1629. expected.sourcePosition = reversed.sourcePosition;
  1630. expected.targetPosition = reversed.targetPosition;
  1631. expected.howMany = reversed.howMany;
  1632. expect( transOp.length ).to.equal( 1 );
  1633. expectOperation( transOp[ 0 ], expected );
  1634. } );
  1635. it( 'range is same as transforming range and is important: convert to NoOperation', () => {
  1636. let transformBy = new MoveOperation(
  1637. op.sourcePosition,
  1638. op.howMany,
  1639. new Position( root, [ 4, 1, 0 ] ),
  1640. baseVersion
  1641. );
  1642. let transOp = transform( op, transformBy );
  1643. expect( transOp.length ).to.equal( 1 );
  1644. expectOperation( transOp[ 0 ], {
  1645. type: NoOperation,
  1646. baseVersion: baseVersion + 1
  1647. } );
  1648. } );
  1649. it( 'range is same as transforming range and is less important: update range path', () => {
  1650. let transformBy = new MoveOperation(
  1651. op.sourcePosition,
  1652. op.howMany,
  1653. new Position( root, [ 4, 1, 0 ] ),
  1654. baseVersion
  1655. );
  1656. let transOp = transform( op, transformBy, true );
  1657. expected.sourcePosition.path = [ 4, 1, 0 ];
  1658. expect( transOp.length ).to.equal( 1 );
  1659. expectOperation( transOp[ 0 ], expected );
  1660. } );
  1661. it( 'range contains transforming range and is important: convert to NoOperation', () => {
  1662. let transformBy = new MoveOperation(
  1663. new Position( root, [ 2, 2, 3 ] ),
  1664. 4,
  1665. new Position( root, [ 4, 1, 0 ] ),
  1666. baseVersion
  1667. );
  1668. let transOp = transform( op, transformBy );
  1669. expect( transOp.length ).to.equal( 1 );
  1670. expectOperation( transOp[ 0 ], {
  1671. type: NoOperation,
  1672. baseVersion: baseVersion + 1
  1673. } );
  1674. } );
  1675. it( 'range contains transforming range and is less important: update range path', () => {
  1676. let transformBy = new MoveOperation(
  1677. new Position( root, [ 2, 2, 3 ] ),
  1678. 4,
  1679. new Position( root, [ 4, 1, 0 ] ),
  1680. baseVersion
  1681. );
  1682. let transOp = transform( op, transformBy, true );
  1683. expected.sourcePosition.path = [ 4, 1, 1 ];
  1684. expect( transOp.length ).to.equal( 1 );
  1685. expectOperation( transOp[ 0 ], expected );
  1686. } );
  1687. it( 'range contains transforming range and target and is important: update range path and target', () => {
  1688. op.targetPosition.path = [ 2, 2, 7 ];
  1689. let transformBy = new MoveOperation(
  1690. new Position( root, [ 2, 2, 3 ] ),
  1691. 5,
  1692. new Position( root, [ 4, 1, 0 ] ),
  1693. baseVersion
  1694. );
  1695. let transOp = transform( op, transformBy );
  1696. expect( transOp.length ).to.equal( 1 );
  1697. expected.sourcePosition.path = [ 4, 1, 1 ];
  1698. expected.targetPosition.path = [ 4, 1, 4 ];
  1699. expectOperation( transOp[ 0 ], expected );
  1700. } );
  1701. it( 'range contains transforming range and target and is less important: update range path and target', () => {
  1702. op.targetPosition.path = [ 2, 2, 7 ];
  1703. let transformBy = new MoveOperation(
  1704. new Position( root, [ 2, 2, 3 ] ),
  1705. 5,
  1706. new Position( root, [ 4, 1, 0 ] ),
  1707. baseVersion
  1708. );
  1709. let transOp = transform( op, transformBy, true );
  1710. expect( transOp.length ).to.equal( 1 );
  1711. expected.sourcePosition.path = [ 4, 1, 1 ];
  1712. expected.targetPosition.path = [ 4, 1, 4 ];
  1713. expectOperation( transOp[ 0 ], expected );
  1714. } );
  1715. it( 'range intersects on left side of transforming range and is important: shrink range', () => {
  1716. let transformBy = new MoveOperation(
  1717. new Position( root, [ 2, 2, 3 ] ),
  1718. 2,
  1719. new Position( root, [ 4, 1, 0 ] ),
  1720. baseVersion
  1721. );
  1722. let transOp = transform( op, transformBy );
  1723. expected.sourcePosition.path = [ 2, 2, 3 ];
  1724. expected.howMany = 1;
  1725. expect( transOp.length ).to.equal( 1 );
  1726. expectOperation( transOp[ 0 ], expected );
  1727. } );
  1728. it( 'range intersects on left side of transforming range and is less important: split into two operations', () => {
  1729. // Get more test cases and better code coverage
  1730. let otherRoot = new RootElement( null );
  1731. let transformBy = new MoveOperation(
  1732. new Position( root, [ 2, 2, 3 ] ),
  1733. 2,
  1734. new Position( otherRoot, [ 4, 1, 0 ] ),
  1735. baseVersion
  1736. );
  1737. let transOp = transform( op, transformBy, true );
  1738. expect( transOp.length ).to.equal( 2 );
  1739. expected.sourcePosition.path = [ 2, 2, 3 ];
  1740. expected.howMany = 1;
  1741. expectOperation( transOp[ 0 ], expected );
  1742. expected.sourcePosition = new Position( otherRoot, [ 4, 1, 1 ] );
  1743. expected.baseVersion++;
  1744. expectOperation( transOp[ 1 ], expected );
  1745. } );
  1746. it( 'range intersects on right side of transforming range and is important: shrink range', () => {
  1747. let transformBy = new MoveOperation(
  1748. new Position( root, [ 2, 2, 5 ] ),
  1749. 2,
  1750. new Position( root, [ 4, 1, 0 ] ),
  1751. baseVersion
  1752. );
  1753. let transOp = transform( op, transformBy );
  1754. expected.howMany = 1;
  1755. expect( transOp.length ).to.equal( 1 );
  1756. expectOperation( transOp[ 0 ], expected );
  1757. } );
  1758. it( 'range intersects on right side of transforming range and is less important: split into two operations', () => {
  1759. let transformBy = new MoveOperation(
  1760. new Position( root, [ 2, 2, 5 ] ),
  1761. 2,
  1762. new Position( root, [ 4, 1, 0 ] ),
  1763. baseVersion
  1764. );
  1765. let transOp = transform( op, transformBy, true );
  1766. expect( transOp.length ).to.equal( 2 );
  1767. expected.sourcePosition.path = [ 4, 1, 0 ];
  1768. expected.howMany = 1;
  1769. expectOperation( transOp[ 0 ], expected );
  1770. expected.sourcePosition.path = op.sourcePosition.path;
  1771. expected.baseVersion++;
  1772. expectOperation( transOp[ 1 ], expected );
  1773. } );
  1774. it( 'range intersects on left side, target inside transforming range and is important: expand move range', () => {
  1775. op.howMany = 4;
  1776. let transformBy = new MoveOperation(
  1777. new Position( root, [ 2, 2, 3 ] ),
  1778. 2,
  1779. new Position( root, [ 2, 2, 6 ] ),
  1780. baseVersion
  1781. );
  1782. let transOp = transform( op, transformBy );
  1783. expect( transOp.length ).to.equal( 1 );
  1784. expected.sourcePosition.path = [ 2, 2, 3 ];
  1785. expected.howMany = 5;
  1786. expectOperation( transOp[ 0 ], expected );
  1787. } );
  1788. it( 'range intersects on left side, target inside transforming range and is less important: expand move range', () => {
  1789. op.howMany = 4;
  1790. let transformBy = new MoveOperation(
  1791. new Position( root, [ 2, 2, 3 ] ),
  1792. 2,
  1793. new Position( root, [ 2, 2, 6 ] ),
  1794. baseVersion
  1795. );
  1796. let transOp = transform( op, transformBy, true );
  1797. expect( transOp.length ).to.equal( 1 );
  1798. expected.sourcePosition.path = [ 2, 2, 3 ];
  1799. expected.howMany = 5;
  1800. expectOperation( transOp[ 0 ], expected );
  1801. } );
  1802. it( 'range intersects on right side of transforming range and is important: shrink range', () => {
  1803. let transformBy = new MoveOperation(
  1804. new Position( root, [ 2, 2, 5 ] ),
  1805. 2,
  1806. new Position( root, [ 4, 1, 0 ] ),
  1807. baseVersion
  1808. );
  1809. let transOp = transform( op, transformBy );
  1810. expected.howMany = 1;
  1811. expect( transOp.length ).to.equal( 1 );
  1812. expectOperation( transOp[ 0 ], expected );
  1813. } );
  1814. it( 'range intersects on right side of transforming range and is less important: split into two operations', () => {
  1815. let transformBy = new MoveOperation(
  1816. new Position( root, [ 2, 2, 5 ] ),
  1817. 2,
  1818. new Position( root, [ 4, 1, 0 ] ),
  1819. baseVersion
  1820. );
  1821. let transOp = transform( op, transformBy, true );
  1822. expect( transOp.length ).to.equal( 2 );
  1823. expected.sourcePosition.path = [ 4, 1, 0 ];
  1824. expected.howMany = 1;
  1825. expectOperation( transOp[ 0 ], expected );
  1826. expected.sourcePosition.path = op.sourcePosition.path;
  1827. expected.baseVersion++;
  1828. expectOperation( transOp[ 1 ], expected );
  1829. } );
  1830. it( 'range intersects, target inside transforming range and is important: split into two operations', () => {
  1831. op.targetPosition.path = [ 2, 2, 7 ];
  1832. let transformBy = new MoveOperation(
  1833. new Position( root, [ 2, 2, 5 ] ),
  1834. 4,
  1835. new Position( root, [ 4, 1, 0 ] ),
  1836. baseVersion
  1837. );
  1838. let transOp = transform( op, transformBy, true );
  1839. expect( transOp.length ).to.equal( 2 );
  1840. expected.sourcePosition.path = [ 4, 1, 0 ];
  1841. expected.targetPosition.path = [ 4, 1, 2 ];
  1842. expected.howMany = 1;
  1843. expectOperation( transOp[ 0 ], expected );
  1844. expected.sourcePosition.path = [ 2, 2, 4 ];
  1845. expected.targetPosition.path = [ 4, 1, 2 ];
  1846. expected.howMany = 1;
  1847. expected.baseVersion++;
  1848. expectOperation( transOp[ 1 ], expected );
  1849. } );
  1850. it( 'range intersects, target inside transforming range and is less important: shrink range', () => {
  1851. op.targetPosition.path = [ 2, 2, 7 ];
  1852. let transformBy = new MoveOperation(
  1853. new Position( root, [ 2, 2, 5 ] ),
  1854. 4,
  1855. new Position( root, [ 4, 1, 0 ] ),
  1856. baseVersion
  1857. );
  1858. let transOp = transform( op, transformBy );
  1859. expect( transOp.length ).to.equal( 1 );
  1860. expected.sourcePosition.path = [ 2, 2, 4 ];
  1861. expected.targetPosition.path = [ 4, 1, 2 ];
  1862. expected.howMany = 1;
  1863. expectOperation( transOp[ 0 ], expected );
  1864. } );
  1865. it( 'range inside transforming range and is important: shrink range', () => {
  1866. op.howMany = 4;
  1867. let transformBy = new MoveOperation(
  1868. new Position( root, [ 2, 2, 5 ] ),
  1869. 2,
  1870. new Position( root, [ 4, 1, 0 ] ),
  1871. baseVersion
  1872. );
  1873. let transOp = transform( op, transformBy );
  1874. expect( transOp.length ).to.equal( 1 );
  1875. expected.howMany = 2;
  1876. expectOperation( transOp[ 0 ], expected );
  1877. } );
  1878. it( 'range inside transforming range and is less important: split into two operations', () => {
  1879. op.howMany = 4;
  1880. let transformBy = new MoveOperation(
  1881. new Position( root, [ 2, 2, 5 ] ),
  1882. 2,
  1883. new Position( root, [ 4, 1, 0 ] ),
  1884. baseVersion
  1885. );
  1886. let transOp = transform( op, transformBy, true );
  1887. expect( transOp.length ).to.equal( 2 );
  1888. expected.sourcePosition.path = [ 4, 1, 0 ];
  1889. expected.howMany = 2;
  1890. expectOperation( transOp[ 0 ], expected );
  1891. expected.sourcePosition.path = [ 2, 2, 4 ];
  1892. expected.howMany = 2;
  1893. expected.baseVersion++;
  1894. expectOperation( transOp[ 1 ], expected );
  1895. } );
  1896. it( 'range and target inside transforming range and is important: no operation update', () => {
  1897. op.howMany = 6;
  1898. let transformBy = new MoveOperation(
  1899. new Position( root, [ 2, 2, 5 ] ),
  1900. 2,
  1901. new Position( root, [ 2, 2, 9 ] ),
  1902. baseVersion
  1903. );
  1904. let transOp = transform( op, transformBy );
  1905. expect( transOp.length ).to.equal( 1 );
  1906. expected.howMany = 6;
  1907. expectOperation( transOp[ 0 ], expected );
  1908. } );
  1909. it( 'range and target inside transforming range and is less important: no operation update', () => {
  1910. op.howMany = 6;
  1911. let transformBy = new MoveOperation(
  1912. new Position( root, [ 2, 2, 5 ] ),
  1913. 2,
  1914. new Position( root, [ 2, 2, 9 ] ),
  1915. baseVersion
  1916. );
  1917. let transOp = transform( op, transformBy, true );
  1918. expect( transOp.length ).to.equal( 1 );
  1919. expected.howMany = 6;
  1920. expectOperation( transOp[ 0 ], expected );
  1921. } );
  1922. } );
  1923. describe( 'by NoOperation', () => {
  1924. it( 'no operation update', () => {
  1925. let transformBy = new NoOperation( baseVersion );
  1926. let transOp = transform( op, transformBy );
  1927. expect( transOp.length ).to.equal( 1 );
  1928. expectOperation( transOp[ 0 ], expected );
  1929. } );
  1930. } );
  1931. } );
  1932. describe( 'NoOperation', () => {
  1933. beforeEach( () => {
  1934. op = new NoOperation( baseVersion );
  1935. expected = {
  1936. type: NoOperation,
  1937. baseVersion: baseVersion + 1
  1938. };
  1939. } );
  1940. describe( 'by InsertOperation', () => {
  1941. it( 'no operation update', () => {
  1942. let transformBy = new InsertOperation(
  1943. new Position( root, [ 0 ] ),
  1944. 'a',
  1945. baseVersion
  1946. );
  1947. let transOp = transform( op, transformBy );
  1948. expect( transOp.length ).to.equal( 1 );
  1949. expectOperation( transOp[ 0 ], expected );
  1950. } );
  1951. } );
  1952. describe( 'by AttributeOperation', () => {
  1953. it( 'no operation update', () => {
  1954. let transformBy = new AttributeOperation(
  1955. new Range(
  1956. new Position( root, [ 0 ] ),
  1957. new Position( root, [ 1 ] )
  1958. ),
  1959. 'foo',
  1960. 'bar',
  1961. 'xyz',
  1962. baseVersion
  1963. );
  1964. let transOp = transform( op, transformBy );
  1965. expect( transOp.length ).to.equal( 1 );
  1966. expectOperation( transOp[ 0 ], expected );
  1967. } );
  1968. } );
  1969. describe( 'by RootAttributeOperation', () => {
  1970. it( 'no operation update', () => {
  1971. let transformBy = new RootAttributeOperation(
  1972. root,
  1973. 'foo',
  1974. null,
  1975. 'bar',
  1976. baseVersion
  1977. );
  1978. let transOp = transform( op, transformBy );
  1979. expect( transOp.length ).to.equal( 1 );
  1980. expectOperation( transOp[ 0 ], expected );
  1981. } );
  1982. } );
  1983. describe( 'by MoveOperation', () => {
  1984. it( 'no operation update', () => {
  1985. let transformBy = new MoveOperation(
  1986. new Position( root, [ 0 ] ),
  1987. 2,
  1988. new Position( root, [ 1 ] ),
  1989. baseVersion
  1990. );
  1991. let transOp = transform( op, transformBy );
  1992. expect( transOp.length ).to.equal( 1 );
  1993. expectOperation( transOp[ 0 ], expected );
  1994. } );
  1995. } );
  1996. describe( 'by NoOperation', () => {
  1997. it( 'no operation update', () => {
  1998. let transformBy = new NoOperation( baseVersion );
  1999. let transOp = transform( op, transformBy );
  2000. expect( transOp.length ).to.equal( 1 );
  2001. expectOperation( transOp[ 0 ], expected );
  2002. } );
  2003. } );
  2004. } );
  2005. } );