Swap type done

Author: Josema

src/index.js

@@ -10,8 +10,9 @@ import Function from './types/Function'
 import Array from './types/Array'
 import Delete from './types/Delete'
 import Replace from './types/Replace'
-import Splice from './types/Splice'
 import Inner from './types/Inner'
+import Splice from './types/Splice'
+import Swap from './types/Swap'
 
 function factory() {
     const patchers = []
@@ -34,8 +35,9 @@ function factory() {
     addType(Array)
     addType(Delete)
     addType(Replace)
-    addType(Splice)
     addType(Inner)
+    addType(Splice)
+    addType(Swap)
 
     return {
         version,
@@ -50,9 +52,10 @@ function factory() {
         TYPE: {
             Delete,
             Replace,
+            Inner,
             Splice,
-            Inner
-        }
+            Swap,
+        },
     }
 }
 

src/types/Swap.js

@@ -1,6 +1,7 @@
 import { ESCAPE_KEY, SWAP_KEY } from '../const'
 import { isValidToEscape } from '../util/isValid'
 import { getUniqueKey } from '../util/get'
+import { isArray } from '../util/is'
 
 export default function Swap(...args) {
     if (!(this instanceof Swap)) {
@@ -25,9 +26,11 @@ Swap.patch = function ({ patch, target, prop, old_value }) {
                     array[swap_a] = array[swap_b]
                     array[swap_b] = temp_item
                 }
+                return Swap.apply(null, swaps.slice(0).reverse())
             }
         }
     }
+    return old_value
 }
 
 Swap.encode = function ({ value }) {

test/type_inner.js

@@ -124,6 +124,7 @@ test('Editing subobject and creating a new one', function (t) {
     const patch = TYPE.Inner({ 0: { a: true }, 1: { b: true } })
     const expected = [{ a: true }, { b: true }]
     testPatchUnpatch(t, target, patch, expected)
+    console.log(target)
 })
 
 test('Encoding unpatch', function (t) {

test/type_splice.js

@@ -34,12 +34,12 @@ test('API', function (t) {
     t.is(mutations.length, 1)
     t.is(result.array, target.array)
     t.true(unpatch.array instanceof TYPE.Splice)
-    // t.deepEqual(unpatch.array.args, [1, 1])
+    t.deepEqual(unpatch.array.args, [1, 1])
 })
 
 test('Patching a non array must do nothing', function (t) {
     const target = { array: 1234 }
-    const patch = { array: TYPE.Splice({ 0: 'b' }) }
+    const patch = { array: TYPE.Splice(0, 0, 5678) }
     const expected = { array: 1234 }
     const { mutations } = testPatchUnpatch(t, target, patch, expected)
     t.is(mutations.length, 0)

test/type_swap.js

@@ -0,0 +1,78 @@
+import test from 'ava'
+import { applyPatch } from '../'
+import { TYPE } from '../'
+import { testEncodeDecode, testPatchUnpatch } from './utils'
+
+test('Valid type', function (t) {
+    const patch = { convert: TYPE.Swap(0, 1) }
+    const expected = { convert: { $w: [0, 1] } }
+    testEncodeDecode(t, patch, expected)
+})
+
+test('Escape', function (t) {
+    const patch = { escape: { $w: [0, 1] } }
+    const expected = { escape: { $escape: { $w: [0, 1] } } }
+    testEncodeDecode(t, patch, expected)
+})
+
+test('Ignore', function (t) {
+    const patch = { ignore: { $w: { a: 2 } } }
+    const expected = { ignore: { $w: { a: 2 } } }
+    testEncodeDecode(t, patch, expected)
+})
+
+test('API', function (t) {
+    const target = { array: ['a', 'b'] }
+    const patch = { array: TYPE.Swap(0, 1) }
+    const expected = { array: ['b', 'a'] }
+    const { unpatch, result, mutations } = testPatchUnpatch(
+        t,
+        target,
+        patch,
+        expected
+    )
+    t.is(mutations.length, 1)
+    t.is(result.array, target.array)
+    t.true(unpatch.array instanceof TYPE.Swap)
+    t.deepEqual(unpatch.array.args, [1, 0])
+})
+
+test('Patching a non array must do nothing', function (t) {
+    const target = { array: 1234 }
+    const patch = { array: TYPE.Swap(0, 1) }
+    const expected = { array: 1234 }
+    const { mutations } = testPatchUnpatch(t, target, patch, expected)
+    t.is(mutations.length, 0)
+})
+
+test('Multiple mutations', function (t) {
+    const target = { array: ['a', 'b', 'c', 'd'] }
+    const patch = { array: TYPE.Swap(0, 2, 1, 3) }
+    const expected = { array: ['c', 'd', 'a', 'b'] }
+    testPatchUnpatch(t, target, patch, expected)
+})
+
+test('Combining swaps', function (t) {
+    const target = { array: ['a', 'b', 'c'] }
+    const patch = { array: TYPE.Swap(0, 1, 2, 1) }
+    const expected = { array: ['b', 'c', 'a'] }
+    testPatchUnpatch(t, target, patch, expected)
+})
+
+test('Repeating swaps', function (t) {
+    const target = { array: ['a', 'b'] }
+    const patch = { array: TYPE.Swap(0, 1, 1, 0) }
+    const expected = { array: ['a', 'b'] }
+    testPatchUnpatch(t, target, patch, expected)
+})
+
+test('Swaping do not mutate inner objects, must be the same instances', function (t) {
+    const target = { array: [{ a: 1 }, { b: 2 }] }
+    const a = target.array[0]
+    const b = target.array[1]
+    const patch = { array: TYPE.Swap(0, 1) }
+    const expected = { array: [{ b: 2 }, { a: 1 }] }
+    testPatchUnpatch(t, target, patch, expected, false)
+    t.is(a, target.array[1])
+    t.is(b, target.array[0])
+})