Merge branch 'master' into typings-pipe-api

Author: benjamine

README.md

@@ -25,6 +25,7 @@ Diff & patch JavaScript objects
     - html (check it at the [Live Demo](http://benjamine.github.com/jsondiffpatch/demo/index.html))
     - annotated json (html), makes the JSON delta format self-explained
     - console (colored), try running ```./node_modules/.bin/jsondiffpatch left.json right.json```
+    - JSON Patch format RFC 6902 support
     - write your own! check [Formatters documentation](docs/formatters.md)
 - BONUS: `jsondiffpatch.clone(obj)` (deep clone)
 

src/filters/lcs.js

@@ -7,7 +7,7 @@ reference: http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
 */
 
 const defaultMatch = function(array1, array2, index1, index2) {
-  return array1[index1] === array2[index2];
+  return array1[ index1 ] === array2[ index2 ];
 };
 
 const lengthMatrix = function(array1, array2, match, context) {
@@ -16,56 +16,56 @@ const lengthMatrix = function(array1, array2, match, context) {
   let x, y;
 
   // initialize empty matrix of len1+1 x len2+1
-  let matrix = [len1 + 1];
+  let matrix = [ len1 + 1 ];
   for (x = 0; x < len1 + 1; x++) {
-    matrix[x] = [len2 + 1];
+    matrix[ x ] = [ len2 + 1 ];
     for (y = 0; y < len2 + 1; y++) {
-      matrix[x][y] = 0;
+      matrix[ x ][ y ] = 0;
     }
   }
   matrix.match = match;
   // save sequence lengths for each coordinate
   for (x = 1; x < len1 + 1; x++) {
     for (y = 1; y < len2 + 1; y++) {
       if (match(array1, array2, x - 1, y - 1, context)) {
-        matrix[x][y] = matrix[x - 1][y - 1] + 1;
+        matrix[ x ][ y ] = matrix[ x - 1 ][ y - 1 ] + 1;
       } else {
-        matrix[x][y] = Math.max(matrix[x - 1][y], matrix[x][y - 1]);
+        matrix[ x ][ y ] = Math.max(matrix[ x - 1 ][ y ], matrix[ x ][ y - 1 ]);
       }
     }
   }
   return matrix;
 };
 
-const backtrack = function(matrix, array1, array2, index1, index2, context) {
-  if (index1 === 0 || index2 === 0) {
-    return {
-      sequence: [],
-      indices1: [],
-      indices2: [],
-    };
-  }
-
-  if (matrix.match(array1, array2, index1 - 1, index2 - 1, context)) {
-    const subsequence = backtrack(
-      matrix,
-      array1,
-      array2,
-      index1 - 1,
-      index2 - 1,
-      context
-    );
-    subsequence.sequence.push(array1[index1 - 1]);
-    subsequence.indices1.push(index1 - 1);
-    subsequence.indices2.push(index2 - 1);
-    return subsequence;
-  }
+const backtrack = function(matrix, array1, array2, context) {
+  let index1 = array1.length;
+  let index2 = array2.length;
+  const subsequence = {
+    sequence: [],
+    indices1: [],
+    indices2: [],
+  };
 
-  if (matrix[index1][index2 - 1] > matrix[index1 - 1][index2]) {
-    return backtrack(matrix, array1, array2, index1, index2 - 1, context);
-  } else {
-    return backtrack(matrix, array1, array2, index1 - 1, index2, context);
+  while (index1 !== 0 && index2 !== 0) {
+    const sameLetter =
+      matrix.match(array1, array2, index1 - 1, index2 - 1, context);
+    if (sameLetter) {
+      subsequence.sequence.unshift(array1[ index1 - 1 ]);
+      subsequence.indices1.unshift(index1 - 1);
+      subsequence.indices2.unshift(index2 - 1);
+      --index1;
+      --index2;
+    } else {
+      const valueAtMatrixAbove = matrix[ index1 ][ index2 - 1 ];
+      const valueAtMatrixLeft = matrix[ index1 - 1 ][ index2 ];
+      if (valueAtMatrixAbove > valueAtMatrixLeft) {
+        --index2;
+      } else {
+        --index1;
+      }
+    }
   }
+  return subsequence;
 };
 
 const get = function(array1, array2, match, context) {
@@ -80,8 +80,6 @@ const get = function(array1, array2, match, context) {
     matrix,
     array1,
     array2,
-    array1.length,
-    array2.length,
     innerContext
   );
   if (typeof array1 === 'string' && typeof array2 === 'string') {

src/index.d.ts

@@ -2,6 +2,23 @@ export interface Formatter {
     format(delta: Delta, original: any): string;
 }
 
+export interface HtmlFormatter extends Formatter {
+    /**
+     * Set whether to show or hide unchanged parts of a diff.
+     * @param show Whether to show unchanged parts
+     * @param node The root element the diff is contained within. (Default: body)
+     * @param delay Transition time in ms. (Default: no transition)
+     */
+    showUnchanged(show: boolean, node?: Element | null, delay?: number): void;
+
+    /**
+     * An alias for showUnchanged(false, ...)
+     * @param node The root element the diff is contained within (Default: body)
+     * @param delay Transition time in ms. (Default: no transition)
+     */
+    hideUnchanged(node?: Element | null, delay?: number): void;
+}
+
 export interface Delta {
     [key: string]: any;
     [key: number]: any;
@@ -167,14 +184,18 @@ export class DiffPatcher {
     unpatch: (right: any, delta: Delta) => any;
 }
 
+export const create: (options?: any) => DiffPatcher
+
 export const formatters: {
-    annotated: Formatter;
-    console: Formatter;
-    html: Formatter;
+  annotated: Formatter;
+  console: Formatter;
+  html: HTMLFormatter;
 };
 
 export const console: Formatter
 
+export const dateReviver: (key: string, value: any) => any;
+
 export const diff: (left: any, right: any) => Delta | undefined;
 export const patch: (left: any, delta: Delta) => any;
 export const reverse: (delta: Delta) => Delta | undefined;

test/index.js

@@ -5,6 +5,8 @@
 import * as jsondiffpatch from '../build/jsondiffpatch.esm';
 import examples from './examples/diffpatch';
 import chai from 'chai';
+
+import lcs from '../src/filters/lcs';
 const expect = chai.expect;
 
 describe('jsondiffpatch', () => {
@@ -726,3 +728,44 @@ describe('DiffPatcher', () => {
     });
   });
 });
+
+describe('lcs', () => {
+  it('should lcs arrays ', () => {
+    expect(lcs.get([], [])).to.deep.equal({
+      sequence: [],
+      indices1: [],
+      indices2: [],
+    });
+
+    expect(lcs.get([1], [2])).to.deep.equal({
+      sequence: [],
+      indices1: [],
+      indices2: [],
+    });
+
+    // indices1 and indices2 show where the sequence
+    // elements are located in the original arrays
+    expect(lcs.get([ 1 ], [ -9, 1 ])).to.deep.equal({
+      sequence: [1],
+      indices1: [0],
+      indices2: [1],
+    });
+  });
+
+  it('should compute diff for large array', () => {
+    const ARRAY_LENGTH = 5000; // js stack is about 50k
+    function randomArray() {
+      let result = [];
+      for (let i = 0; i < ARRAY_LENGTH; i++) {
+        if (Math.random() > 0.5) {
+          result.push('A');
+        } else {
+          result.push('B');
+        }
+      }
+      return result;
+    }
+
+    lcs.get(randomArray(), randomArray());
+  });
+});