transform.js 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359
  1. /**
  2. * @license Copyright (c) 2003-2017, CKSource - Frederico Knabben. All rights reserved.
  3. * For licensing, see LICENSE.md.
  4. */
  5. import transformations from '../../../../src/model/delta/basic-transformations'; // eslint-disable-line no-unused-vars
  6. import deltaTransform from '../../../../src/model/delta/transform';
  7. const transformDeltaSets = deltaTransform.transformDeltaSets;
  8. import Document from '../../../../src/model/document';
  9. import Element from '../../../../src/model/element';
  10. import Text from '../../../../src/model/text';
  11. import Position from '../../../../src/model/position';
  12. import Delta from '../../../../src/model/delta/delta';
  13. import InsertDelta from '../../../../src/model/delta/insertdelta';
  14. import RemoveDelta from '../../../../src/model/delta/removedelta';
  15. import SplitDelta from '../../../../src/model/delta/splitdelta';
  16. import NoOperation from '../../../../src/model/operation/nooperation';
  17. import MoveOperation from '../../../../src/model/operation/moveoperation';
  18. import RemoveOperation from '../../../../src/model/operation/removeoperation';
  19. import InsertOperation from '../../../../src/model/operation/insertoperation';
  20. import {
  21. expectDelta,
  22. getInsertDelta,
  23. getSplitDelta,
  24. getRemoveDelta
  25. } from '../../../../tests/model/delta/transform/_utils/utils';
  26. describe( 'transform', () => {
  27. let doc, root, baseVersion;
  28. beforeEach( () => {
  29. doc = new Document();
  30. root = doc.createRoot();
  31. root.appendChildren( new Element( 'p', null, new Text( 'foobar' ) ) );
  32. baseVersion = doc.version;
  33. } );
  34. describe( 'transformDeltaSets', () => {
  35. it( 'should use deltaTransform.transform', () => {
  36. sinon.spy( deltaTransform, 'transform' );
  37. const insertDelta = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'xxx' ), baseVersion );
  38. const removeDelta = getRemoveDelta( new Position( root, [ 0, 0 ] ), 2, baseVersion );
  39. transformDeltaSets( [ insertDelta ], [ removeDelta ] );
  40. expect( deltaTransform.transform.called ).to.be.true;
  41. deltaTransform.transform.restore();
  42. } );
  43. it( 'should transform two deltas', () => {
  44. const insertDelta = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'xxx' ), baseVersion );
  45. const removeDelta = getRemoveDelta( new Position( root, [ 0, 0 ] ), 2, baseVersion );
  46. const { deltasA, deltasB } = transformDeltaSets( [ insertDelta ], [ removeDelta ] );
  47. expect( deltasA.length ).to.equal( 1 );
  48. expect( deltasB.length ).to.equal( 1 );
  49. expectDelta( deltasA[ 0 ], {
  50. type: InsertDelta,
  51. operations: [
  52. {
  53. type: InsertOperation,
  54. position: new Position( root, [ 0, 2 ] ),
  55. baseVersion: 1
  56. }
  57. ]
  58. } );
  59. expectDelta( deltasB[ 0 ], {
  60. type: RemoveDelta,
  61. operations: [
  62. {
  63. type: RemoveOperation,
  64. sourcePosition: new Position( root, [ 0, 0 ] ),
  65. howMany: 2,
  66. baseVersion: 1
  67. }
  68. ]
  69. } );
  70. } );
  71. it( 'should transform two deltas - reverse', () => {
  72. const insertDelta = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'xxx' ), baseVersion );
  73. const removeDelta = getRemoveDelta( new Position( root, [ 0, 0 ] ), 2, baseVersion );
  74. const { deltasA, deltasB } = transformDeltaSets( [ removeDelta ], [ insertDelta ] );
  75. expect( deltasA.length ).to.equal( 1 );
  76. expect( deltasB.length ).to.equal( 1 );
  77. expectDelta( deltasA[ 0 ], {
  78. type: RemoveDelta,
  79. operations: [
  80. {
  81. type: RemoveOperation,
  82. sourcePosition: new Position( root, [ 0, 0 ] ),
  83. howMany: 2,
  84. baseVersion: 1
  85. }
  86. ]
  87. } );
  88. expectDelta( deltasB[ 0 ], {
  89. type: InsertDelta,
  90. operations: [
  91. {
  92. type: InsertOperation,
  93. position: new Position( root, [ 0, 2 ] ),
  94. baseVersion: 1
  95. }
  96. ]
  97. } );
  98. } );
  99. it( 'should transform two arrays of deltas', () => {
  100. const splitDelta = getSplitDelta( new Position( root, [ 0, 3 ] ), new Element( 'p' ), 3, baseVersion );
  101. const insertDeltaX = getInsertDelta( new Position( root, [ 0, 3 ] ), new Text( 'xxx' ), baseVersion + 2 );
  102. const removeDelta = getRemoveDelta( new Position( root, [ 0, 2 ] ), 2, baseVersion );
  103. const insertDeltaY = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'yyy' ), baseVersion + 1 );
  104. const { deltasA, deltasB } = transformDeltaSets( [ splitDelta, insertDeltaX ], [ removeDelta, insertDeltaY ], true );
  105. expect( deltasA.length ).to.equal( 3 );
  106. expect( deltasB.length ).to.equal( 2 );
  107. expectDelta( deltasA[ 0 ], {
  108. type: SplitDelta,
  109. operations: [
  110. {
  111. type: InsertOperation,
  112. position: new Position( root, [ 1 ] ),
  113. baseVersion: 2
  114. },
  115. {
  116. type: MoveOperation,
  117. sourcePosition: new Position( root, [ 0, 2 ] ),
  118. howMany: 5,
  119. targetPosition: new Position( root, [ 1, 0 ] ),
  120. baseVersion: 3
  121. }
  122. ]
  123. } );
  124. expectDelta( deltasA[ 1 ], {
  125. type: InsertDelta,
  126. operations: [
  127. {
  128. type: InsertOperation,
  129. position: new Position( root, [ 0, 2 ] ),
  130. baseVersion: 4
  131. }
  132. ]
  133. } );
  134. expectDelta( deltasA[ 2 ], {
  135. type: Delta,
  136. operations: [
  137. {
  138. type: NoOperation,
  139. baseVersion: 5
  140. }
  141. ]
  142. } );
  143. expectDelta( deltasB[ 0 ], {
  144. type: RemoveDelta,
  145. operations: [
  146. {
  147. type: RemoveOperation,
  148. sourcePosition: new Position( root, [ 1, 0 ] ),
  149. howMany: 1,
  150. baseVersion: 3
  151. },
  152. {
  153. type: RemoveOperation,
  154. sourcePosition: new Position( root, [ 0, 2 ] ),
  155. howMany: 1,
  156. baseVersion: 4
  157. }
  158. ]
  159. } );
  160. expectDelta( deltasB[ 1 ], {
  161. type: InsertDelta,
  162. operations: [
  163. {
  164. type: InsertOperation,
  165. position: new Position( root, [ 1, 2 ] ),
  166. baseVersion: 5
  167. }
  168. ]
  169. } );
  170. } );
  171. it( 'should transform two arrays of deltas - reverse', () => {
  172. const splitDelta = getSplitDelta( new Position( root, [ 0, 3 ] ), new Element( 'p' ), 3, baseVersion );
  173. const insertDeltaX = getInsertDelta( new Position( root, [ 0, 3 ] ), new Text( 'xxx' ), baseVersion + 2 );
  174. const removeDelta = getRemoveDelta( new Position( root, [ 0, 2 ] ), 2, baseVersion );
  175. const insertDeltaY = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'yyy' ), baseVersion + 1 );
  176. const { deltasA, deltasB } = transformDeltaSets( [ removeDelta, insertDeltaY ], [ splitDelta, insertDeltaX ], true );
  177. expect( deltasA.length ).to.equal( 2 );
  178. expect( deltasB.length ).to.equal( 3 );
  179. expectDelta( deltasA[ 0 ], {
  180. type: RemoveDelta,
  181. operations: [
  182. {
  183. type: RemoveOperation,
  184. sourcePosition: new Position( root, [ 1, 0 ] ),
  185. howMany: 1,
  186. baseVersion: 3
  187. },
  188. {
  189. type: RemoveOperation,
  190. sourcePosition: new Position( root, [ 0, 2 ] ),
  191. howMany: 1,
  192. baseVersion: 4
  193. }
  194. ]
  195. } );
  196. expectDelta( deltasA[ 1 ], {
  197. type: InsertDelta,
  198. operations: [
  199. {
  200. type: InsertOperation,
  201. position: new Position( root, [ 1, 2 ] ),
  202. baseVersion: 5
  203. }
  204. ]
  205. } );
  206. expectDelta( deltasB[ 0 ], {
  207. type: SplitDelta,
  208. operations: [
  209. {
  210. type: InsertOperation,
  211. position: new Position( root, [ 1 ] ),
  212. baseVersion: 2
  213. },
  214. {
  215. type: MoveOperation,
  216. sourcePosition: new Position( root, [ 0, 2 ] ),
  217. howMany: 5,
  218. targetPosition: new Position( root, [ 1, 0 ] ),
  219. baseVersion: 3
  220. }
  221. ]
  222. } );
  223. expectDelta( deltasB[ 1 ], {
  224. type: InsertDelta,
  225. operations: [
  226. {
  227. type: InsertOperation,
  228. position: new Position( root, [ 0, 2 ] ),
  229. baseVersion: 4
  230. }
  231. ]
  232. } );
  233. expectDelta( deltasB[ 2 ], {
  234. type: Delta,
  235. operations: [
  236. {
  237. type: NoOperation,
  238. baseVersion: 5
  239. }
  240. ]
  241. } );
  242. } );
  243. it( 'importance flag - first set is important', () => {
  244. const insertDeltaA = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'xxx' ), baseVersion );
  245. const insertDeltaB = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'yyy' ), baseVersion );
  246. const { deltasA, deltasB } = transformDeltaSets( [ insertDeltaA ], [ insertDeltaB ], true );
  247. expectDelta( deltasA[ 0 ], {
  248. type: InsertDelta,
  249. operations: [
  250. {
  251. type: InsertOperation,
  252. position: new Position( root, [ 0, 4 ] ),
  253. baseVersion: 1
  254. }
  255. ]
  256. } );
  257. expectDelta( deltasB[ 0 ], {
  258. type: InsertDelta,
  259. operations: [
  260. {
  261. type: InsertOperation,
  262. position: new Position( root, [ 0, 7 ] ),
  263. baseVersion: 1
  264. }
  265. ]
  266. } );
  267. } );
  268. it( 'importance flag - second set is important', () => {
  269. const insertDeltaA = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'xxx' ), baseVersion );
  270. const insertDeltaB = getInsertDelta( new Position( root, [ 0, 4 ] ), new Text( 'yyy' ), baseVersion );
  271. const { deltasA, deltasB } = transformDeltaSets( [ insertDeltaA ], [ insertDeltaB ], false );
  272. expectDelta( deltasA[ 0 ], {
  273. type: InsertDelta,
  274. operations: [
  275. {
  276. type: InsertOperation,
  277. position: new Position( root, [ 0, 7 ] ),
  278. baseVersion: 1
  279. }
  280. ]
  281. } );
  282. expectDelta( deltasB[ 0 ], {
  283. type: InsertDelta,
  284. operations: [
  285. {
  286. type: InsertOperation,
  287. position: new Position( root, [ 0, 4 ] ),
  288. baseVersion: 1
  289. }
  290. ]
  291. } );
  292. } );
  293. it( 'should not modify original deltas or arrays', () => {
  294. const insertDeltaA = getInsertDelta( new Position( root, [ 0, 0 ] ), new Text( 'x' ), baseVersion );
  295. const insertDeltaB = getInsertDelta( new Position( root, [ 1, 0 ] ), new Text( 'y' ), baseVersion );
  296. const originalDeltasA = [ insertDeltaA ];
  297. const originalDeltasB = [ insertDeltaB ];
  298. const { deltasA, deltasB } = transformDeltaSets( originalDeltasA, originalDeltasB, false );
  299. expect( deltasA ).to.not.equal( originalDeltasA );
  300. expect( deltasB ).to.not.equal( originalDeltasB );
  301. expect( deltasA[ 0 ] ).to.not.equal( originalDeltasA[ 0 ] );
  302. expect( deltasB[ 0 ] ).to.not.equal( originalDeltasB[ 0 ] );
  303. } );
  304. } );
  305. } );