Checking for diff ops in Maps contained in Sequences

Author: brenoferreira

src/diff.js

@@ -1,9 +1,77 @@
 'use strict';
 
-var mapDiff = require('./mapDiff');
-var sequenceDiff = require('./sequenceDiff');
+
+var Immutable = require('immutable');
 var utils = require('./utils');
-var isIndexed = utils.isIndexed;
+var lcs = require('./lcs');
+var appendPath = utils.appendPath,
+                  op = utils.op,
+                  isMap = utils.isMap,
+                  isIndexed = utils.isIndexed;
+
+var mapDiff = function(a, b, p){
+  var ops = [];
+  var path = p || '';
+
+  if(Immutable.is(a, b)){ return ops; }
+
+  a.forEach(function(aValue, aKey){
+    if(!b.has(aKey)){
+      ops.push( op('remove', appendPath(path, aKey)) );
+    }
+    else if(isMap(b.get(aKey))){
+      ops = ops.concat(mapDiff(aValue, b.get(aKey), appendPath(path, aKey)));
+    }
+    else if(isIndexed(b.get(aKey)) && isIndexed(aValue)){
+      ops = ops.concat(sequenceDiff(aValue, b.get(aKey), appendPath(path, aKey)));
+    }
+  });
+
+  b.forEach(function(bValue, bKey){
+    if(!a.has(bKey)){
+      ops.push( op('add', appendPath(path, bKey), bValue) );
+    }
+    else{
+      var aValue = a.get(bKey);
+      var areDifferentValues = (aValue !== bValue) && !isMap(aValue) && !isIndexed(aValue);
+      if(areDifferentValues) {
+        ops.push(op('replace', appendPath(path, bKey), bValue));
+      }
+    }
+  });
+
+  return ops;
+};
+
+var sequenceDiff = function (a, b, p) {
+  var path = p || '';
+  if(Immutable.is(a, b)){ return []; }
+
+  var lcsDiff = lcs.diff(a, b);
+
+  var pathIndex = 0;
+  var result = [];
+  lcsDiff.forEach(function (diff, i) {
+    if(diff.op === '='){ pathIndex++; }
+    else if(diff.op === '!='){
+      if(isMap(diff.val) && isMap(diff.newVal)){
+        var mapDiffs = mapDiff(diff.val, diff.newVal, appendPath(path, pathIndex));
+        result = result.concat(mapDiffs);
+      }
+      else{
+        result.push(op('replace', appendPath(path, pathIndex), diff.newVal));
+      }
+      pathIndex++;
+    }
+    else if(diff.op === '+'){
+      result.push(op('add', appendPath(path, pathIndex), diff.val));
+      pathIndex++;
+    }
+    else if(diff.op === '-'){ result.push(op('remove', appendPath(path, pathIndex))); }
+  });
+
+  return result;
+};
 
 module.exports = function(a, b){
   if(isIndexed(a) && isIndexed(b)){ return sequenceDiff(a, b); }

src/lcs.js

@@ -37,6 +37,7 @@ var lcs = function(xs, ys){
 };
 
 var DiffResult = Immutable.Record({op: '=', val: null});
+var ReplaceResult = Immutable.Record({op: '!=', val: null, newVal: null});
 
 /**
  * Returns the resulting diff operations of LCS between two sequences
@@ -59,9 +60,9 @@ var printDiff = function(matrix, xs, ys, i, j) {
     }));
   }
   else if (i > 0 && j > 0 && i === j && !Immutable.is(xs.get(i-1), ys.get(j-1))) {
-    return printDiff(matrix, xs, ys, i - 1, j - 1).concat(new DiffResult({
-      op: '!=',
-      val: ys.get(i - 1)
+    return printDiff(matrix, xs, ys, i - 1, j - 1).concat(new ReplaceResult({
+      val: xs.get(i - 1),
+      newVal: ys.get(i - 1)
     }));
   }
   else {

src/mapDiff.js

@@ -3,6 +3,7 @@
 var diff = require('../src/diff');
 var Immutable = require('Immutable');
 var JSC = require('jscheck');
+var assert = require('assert');
 var opsAreEqual = require('./opsAreEqual');
 
 describe('Map diff', function(){
@@ -339,4 +340,17 @@ describe('Map diff', function(){
       ]
     );
   });
+
+  it('check map in indexed sequence', function(){
+    var array1 = [{a: 1}, {a: 2}, {a: 3}];
+    var array2 = [{a: 1}, {a: 2, b:2.5}, {a: 3}];
+
+    var list1 = Immutable.fromJS(array1);
+    var list2 = Immutable.fromJS(array2);
+
+    var result = diff(list1, list2);
+    var expected = [{op: 'add', path: '/1/b', value: 2.5}];
+
+    assert.ok(result.every(function(op, i){ return opsAreEqual(op, expected[i]); }));
+  });
 });

src/sequenceDiff.js

@@ -43,7 +43,7 @@ describe('lcs', function() {
       {op: '=', val: 1},
       {op: '=', val: 2},
       {op: '=', val: 3},
-      {op: '!=', val: 5},
+      {op: '!=', val: 4, newVal: 5},
       {op: '+', val: 6},
       {op: '+', val: 7}
     ];