Implemented diffJson

diff.js

@@ -127,8 +127,11 @@ var JsDiff = (function() {
         while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
           newPos++;
           oldPos++;
-
-          this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
+          var value = newString[newPos];
+          if (this.useLongestToken && oldString[oldPos].length > value.length) {
+            value = oldString[oldPos];
+          }
+          this.pushComponent(basePath.components, value, undefined, undefined);
         }
         basePath.newPos = newPos;
         return oldPos;
@@ -183,6 +186,63 @@ var JsDiff = (function() {
     return retLines;
   };
 
+  JsonDiff = new Diff();
+  // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+  // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
+  JsonDiff.useLongestToken = true;
+  JsonDiff.tokenize = LineDiff.tokenize;
+  JsonDiff.equals = function(left, right) {
+    return LineDiff.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'));
+  };
+
+  var objectPrototypeToString = Object.prototype.toString;
+
+  // This function handles the presence of circular references by bailing out when encountering an
+  // object that is already on the "stack" of items being processed.
+  function canonicalize(obj, stack, replacementStack) {
+    stack = stack || [];
+    replacementStack = replacementStack || [];
+
+    var i;
+
+    for (var i = 0 ; i < stack.length ; i += 1) {
+      if (stack[i] === obj) {
+        return replacementStack[i];
+      }
+    }
+
+    var canonicalizedObj;
+
+    if ('[object Array]' === objectPrototypeToString.call(obj)) {
+      stack.push(obj);
+      canonicalizedObj = new Array(obj.length);
+      replacementStack.push(canonicalizedObj);
+      for (i = 0 ; i < obj.length ; i += 1) {
+        canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack);
+      }
+      stack.pop();
+      replacementStack.pop();
+    } else if (typeof obj === 'object' && obj !== null) {
+      stack.push(obj);
+      canonicalizedObj = {};
+      replacementStack.push(canonicalizedObj);
+      var sortedKeys = [];
+      for (var key in obj) {
+        sortedKeys.push(key);
+      }
+      sortedKeys.sort();
+      for (i = 0 ; i < sortedKeys.length ; i += 1) {
+        var key = sortedKeys[i];
+        canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack);
+      }
+      stack.pop();
+      replacementStack.pop();
+    } else {
+      canonicalizedObj = obj;
+    }
+    return canonicalizedObj;
+  };
+
   return {
     Diff: Diff,
 
@@ -191,6 +251,13 @@ var JsDiff = (function() {
     diffWordsWithSpace: function(oldStr, newStr) { return WordWithSpaceDiff.diff(oldStr, newStr); },
     diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },
 
+    diffJson: function(oldObj, newObj) {
+      return JsonDiff.diff(
+        typeof oldObj === 'string' ? oldObj : JSON.stringify(canonicalize(oldObj), undefined, "  "),
+        typeof newObj === 'string' ? newObj : JSON.stringify(canonicalize(newObj), undefined, "  ")
+      );
+    },
+
     diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },
 
     createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
@@ -360,7 +427,9 @@ var JsDiff = (function() {
         ret.push([(change.added ? 1 : change.removed ? -1 : 0), change.value]);
       }
       return ret;
-    }
+    },
+
+    canonicalize: canonicalize
   };
 })();
 

test/canonicalize.js

@@ -0,0 +1,37 @@
+const VERBOSE = false;
+
+var diff = require('../diff');
+
+function getKeys(obj) {
+  var keys = [];
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+
+describe('#canonicalize', function() {
+  it('should put the keys in canonical order', function() {
+    getKeys(diff.canonicalize({b: 456, a: 123})).should.eql(['a', 'b']);
+  });
+
+  it('should dive into nested objects', function() {
+    var canonicalObj = diff.canonicalize({b: 456, a: {d: 123, c: 456}});
+    getKeys(canonicalObj.a).should.eql(['c', 'd']);
+  });
+
+  it('should dive into nested arrays', function() {
+    var canonicalObj = diff.canonicalize({b: 456, a: [789, {d: 123, c: 456}]});
+    getKeys(canonicalObj.a[1]).should.eql(['c', 'd']);
+  });
+
+  it('should handle circular references correctly', function() {
+    var obj = {b: 456};
+    obj.a = obj;
+    var canonicalObj = diff.canonicalize(obj);
+    getKeys(canonicalObj).should.eql(['a', 'b']);
+    getKeys(canonicalObj.a).should.eql(['a', 'b']);
+  });
+});

test/diffTest.js

@@ -112,6 +112,66 @@ describe('#diffLines', function() {
   });
 });
 
+describe('#diffJson', function() {
+  it('should accept objects', function() {
+    diff.diffJson(
+      {a: 123, b: 456, c: 789},
+      {a: 123, b: 456}
+    ).should.eql([
+      { value: '{\n  "a": 123,\n  "b": 456,\n', added: undefined, removed: undefined },
+      { value: '  "c": 789\n', added: undefined, removed: true },
+      { value: '}', added: undefined, removed: undefined }
+    ]);
+  });
+
+  it('should accept objects with nested structures', function() {
+    diff.diffJson(
+      {a: 123, b: 456, c: [1, 2, {foo: 'bar'}, 4]},
+      {a: 123, b: 456, c: [1, {foo: 'bar'}, 4]}
+    ).should.eql([
+      { value: '{\n  "a": 123,\n  "b": 456,\n  "c": [\n    1,\n', added: undefined, removed: undefined },
+      { value: '    2,\n', added: undefined, removed: true },
+      { value: '    {\n      "foo": "bar"\n    },\n    4\n  ]\n}', added: undefined, removed: undefined }
+    ]);
+  });
+
+  it('should accept already stringified JSON', function() {
+    diff.diffJson(
+      JSON.stringify({a: 123, b: 456, c: 789}, undefined, "  "),
+      JSON.stringify({a: 123, b: 456}, undefined, "  ")
+    ).should.eql([
+      { value: '{\n  "a": 123,\n  "b": 456,\n', added: undefined, removed: undefined },
+      { value: '  "c": 789\n', added: undefined, removed: true },
+      { value: '}', added: undefined, removed: undefined }
+    ]);
+  });
+
+  it('should ignore trailing comma on the previous line when the property has been removed', function() {
+    var diffResult = diff.diffJson(
+      {a: 123, b: 456, c: 789},
+      {a: 123, b: 456});
+    diff.convertChangesToXML(diffResult).should.equal('{\n  &quot;a&quot;: 123,\n  &quot;b&quot;: 456,\n<del>  &quot;c&quot;: 789\n</del>}');
+  });
+
+  it('should ignore the missing trailing comma on the last line when a property has been added after it', function() {
+    var diffResult = diff.diffJson(
+      {a: 123, b: 456},
+      {a: 123, b: 456, c: 789});
+    diff.convertChangesToXML(diffResult).should.equal('{\n  &quot;a&quot;: 123,\n  &quot;b&quot;: 456,\n<ins>  &quot;c&quot;: 789\n</ins>}');
+  });
+
+  it('should throw an error if one of the objects being diffed has a circular reference', function() {
+    var circular = {foo: 123};
+    circular.bar = circular;
+    (function () {
+      diff.diffJson(
+        circular,
+        {foo: 123, bar: {}}
+      );
+    }).should.throw('Converting circular structure to JSON');
+  });
+});
+
 describe('convertToDMP', function() {
   it('should output diff-match-patch format', function() {
     var diffResult = diff.diffWords('New Value  ', 'New  ValueMoreData ');