Fixing expectedIndex for move items

The last change didn't correctly set the expected index on move source
items which prevents us from updating Unexpected that needs these
indexes.

Author: sunesimonsen

lib/arrayChanges.js

@@ -59,6 +59,13 @@ module.exports = function arrayChanges(actual, expected, equal, similar, options
         return i;
     }
 
+
+    function findMoveTargetWithId(id) {
+        return mutatedArray.find(function (diffItem) {
+            return diffItem.type === 'moveTarget' && diffItem.id === id;
+        });
+    }
+
     var removes = itemsDiff.filter(function (diffItem) {
         return diffItem.type === 'remove';
     });
@@ -76,15 +83,13 @@ module.exports = function arrayChanges(actual, expected, equal, similar, options
         return diffItem.type === 'move';
     });
 
-
+    var ids = 0;
     moves.forEach(function (diffItem) {
         var moveFromIndex = offsetIndex(diffItem.from + 1) - 1;
         var removed = mutatedArray.slice(moveFromIndex, diffItem.howMany + moveFromIndex);
         removed.forEach(function (v, index) {
             v.type = 'moveSource';
-            v.expectedIndex = offsetIndex(diffItem.to + index);
-            v.expected = expected[v.expectedIndex];
-            v.equal = equal(v.value, v.expected);
+            v.id = ids++;
         });
         var added = removed.map(function (v, index) {
             return extend({}, v, { last: false, type: 'moveTarget' });
@@ -93,7 +98,6 @@ module.exports = function arrayChanges(actual, expected, equal, similar, options
         Array.prototype.splice.apply(mutatedArray, [insertIndex, 0].concat(added));
     });
 
-
     var inserts = itemsDiff.filter(function (diffItem) {
         return diffItem.type === 'insert';
     });
@@ -114,14 +118,27 @@ module.exports = function arrayChanges(actual, expected, equal, similar, options
     var offset = 0;
     mutatedArray.forEach(function (diffItem, index) {
         var type = diffItem.type;
-        if (type === 'remove' || type === 'moveSource') {
+        if (type === 'moveTarget') {
+            diffItem.expected = expected[offset + index];
+            diffItem.expectedIndex = offset + index;
+            diffItem.equal = equal(diffItem.value, diffItem.expected);
+        } else if (type === 'remove' || type === 'moveSource') {
             offset -= 1;
         } else if (type === 'similar') {
             diffItem.expected = expected[offset + index];
             diffItem.expectedIndex = offset + index;
         }
     });
 
+    mutatedArray.forEach(function (diffItem) {
+        if (diffItem.type === 'moveSource') {
+            var moveTarget = findMoveTargetWithId(diffItem.id);
+            diffItem.expected = moveTarget.expected;
+            diffItem.expectedIndex = moveTarget.expectedIndex;
+            diffItem.equal = moveTarget.equal;
+        }
+    });
+
     var conflicts = mutatedArray.reduce(function (conflicts, item) {
         return item.type === 'similar' || item.type === 'moveSource' || item.type === 'moveTarget' ? conflicts : conflicts + 1;
     }, 0);

test/arrayChanges.spec.js

@@ -109,11 +109,11 @@ describe('array-changes', function () {
         expect(arrayChanges([1, 2, 3, 0], [0, 1, 2, 3], function (a, b) {
             return a === b;
         }), 'to equal', [
-            { type: 'moveTarget', value: 0, actualIndex: 3, expected: 0, expectedIndex: 0, equal: true, last: false },
+            { type: 'moveTarget', value: 0, actualIndex: 3, expected: 0, expectedIndex: 0, id: 0, equal: true, last: false },
             { type: 'equal', value: 1, actualIndex: 0, expected: 1, expectedIndex: 1 },
             { type: 'equal', value: 2, actualIndex: 1, expected: 2, expectedIndex: 2 },
             { type: 'equal', value: 3, actualIndex: 2, expected: 3, expectedIndex: 3 },
-            { type: 'moveSource', value: 0, actualIndex: 3, expected: 0, expectedIndex: 0, equal: true, last: true }
+            { type: 'moveSource', value: 0, actualIndex: 3, expected: 0, expectedIndex: 0, id: 0, equal: true, last: true }
         ]);
     });
 
@@ -122,9 +122,9 @@ describe('array-changes', function () {
             return a === b;
         }), 'to equal', [
             { type: 'equal', value: 0, actualIndex: 0, expected: 0, expectedIndex: 0 },
-            { type: 'moveTarget', value: 2, actualIndex: 2, expected: 2, expectedIndex: 1, equal: true, last: false },
+            { type: 'moveTarget', value: 2, actualIndex: 2, expected: 2, expectedIndex: 1, id: 0, equal: true, last: false },
             { type: 'equal', value: 1, actualIndex: 1, expected: 1, expectedIndex: 2 },
-            { type: 'moveSource', value: 2, actualIndex: 2, expected: 2, expectedIndex: 1, equal: true },
+            { type: 'moveSource', value: 2, actualIndex: 2, expected: 2, expectedIndex: 1, id: 0, equal: true },
             { type: 'equal', value: 3, actualIndex: 3, expected: 3, expectedIndex: 3, last: true }
         ]);
     });
@@ -451,6 +451,7 @@ describe('array-changes', function () {
                 expected: { kind: 1, type: 'tag', name: 'p', children: [{ data: 'Hello world 2025', type: 'text' }], attribs: {} },
                 actualIndex: 1,
                 expectedIndex: 0,
+                id: 0,
                 equal: false,
                 last: false
             },
@@ -467,9 +468,27 @@ describe('array-changes', function () {
                 expected: { kind: 1, type: 'tag', name: 'p', children: [{ data: 'Hello world 2025', type: 'text' }], attribs: {} },
                 actualIndex: 1,
                 expectedIndex: 0,
+                id: 0,
                 equal: false,
                 last: true
             }
         ]);
     });
+
+    it("handles moves where no items are similar", function () {
+        var a = ['a', 'b', 'c'];
+        var b = ['c', 'b', 'a'];
+
+        expect(arrayChanges(a, b, function (a, b) {
+            return expect.equal(a, b);
+        }, function () {
+            return false;
+        }), 'to equal', [
+            { type: 'moveTarget', value: 'c', actualIndex: 2, last: false, expected: 'c', expectedIndex: 0, id: 1, equal: true },
+            { type: 'moveTarget', value: 'b', actualIndex: 1, last: false, expected: 'b', expectedIndex: 1, id: 0, equal: true },
+            { type: 'equal', value: 'a', actualIndex: 0, expected: 'a', expectedIndex: 2 },
+            { type: 'moveSource', value: 'b', actualIndex: 1, expected: 'b', expectedIndex: 1, id: 0, equal: true },
+            { type: 'moveSource', value: 'c', actualIndex: 2, expected: 'c', expectedIndex: 0, id: 1, equal: true, last: true }
+        ]);
+    });
 });

test/arraydiff.spec.js

@@ -27,7 +27,6 @@ describe('arraydiff', function () {
         var out = before.slice();
         for (var i = 0; i < diff.length; i++) {
             var item = diff[i];
-            // console.log 'applying:', out, item
             if (item.type === 'insert') {
                 insert(out, item.index, item.values);
             } else if (item.type === 'remove') {