@twick/2d 0.11.0

package/src/lib/code/diff.test.ts

@@ -0,0 +1,311 @@
+import {expect, test} from 'vitest';
+import {patienceDiff} from './diff';
+
+test('should find simple strings', () => {
+  const result = patienceDiff(
+    ['abc', 'def', 'ghi'],
+    ['abc', 'def', 'ghi', 'jkl'],
+  );
+
+  // printDiff(result);
+  /*
+      abc
+      def
+      ghi
+    + jkl
+  */
+
+  expect(result).toMatchObject({
+    lines: [
+      // We don't care too much about the first three line results
+      {},
+      {},
+      {},
+      {
+        line: 'jkl',
+        // We care that we know that this line was not there.
+        aIndex: -1,
+        bIndex: 3,
+      },
+    ],
+  });
+});
+
+test('should diff code effectively', () => {
+  const result = patienceDiff(
+    `function test() {
+  console.log('hello world');
+}`.split('\n'),
+    `function test() {
+  console.log('hello world');
+}
+
+function other() {
+  return 5;
+}`.split('\n'),
+  );
+
+  // printDiff(result);
+  /*
+      function test() {
+        console.log('hello world');
+      }
+    + 
+    + function other() {
+    +   return 5;
+    + }
+  */
+
+  expect(result).toMatchObject({
+    lines: [
+      {
+        line: 'function test() {',
+      },
+      {
+        line: "  console.log('hello world');",
+      },
+      {
+        line: '}',
+      },
+      {
+        line: '',
+      },
+      {
+        line: 'function other() {',
+        // Make sure this line was added
+        aIndex: -1,
+      },
+      {
+        line: '  return 5;',
+        aIndex: -1,
+      },
+      {
+        line: '}',
+        aIndex: -1,
+      },
+    ],
+  });
+});
+
+test('should diff code movement effectively', () => {
+  const result = patienceDiff(
+    `function test() {
+  console.log('hello world');
+}
+
+function other() {
+  return 5;
+}`.split('\n'),
+    `function other() {
+  return 5;
+}
+
+function test() {
+  console.log('hello world');
+}`.split('\n'),
+  );
+
+  // printDiff(result);
+  /*
+    - function test() {
+    -   console.log('hello world');
+    - }
+    - 
+      function other() {
+        return 5;
+      }
+    + 
+    + function test() {
+    +   console.log('hello world');
+    + }
+  */
+
+  expect(result).toMatchObject({
+    lines: [
+      {
+        line: 'function test() {',
+        // Make sure this line was removed
+        bIndex: -1,
+      },
+      {
+        line: "  console.log('hello world');",
+        bIndex: -1,
+      },
+      {
+        line: '}',
+        bIndex: -1,
+      },
+      {
+        line: '',
+        bIndex: -1,
+      },
+      {
+        line: 'function other() {',
+      },
+      {
+        line: '  return 5;',
+      },
+      {
+        line: '}',
+      },
+      {
+        line: '',
+        aIndex: -1,
+      },
+      {
+        line: 'function test() {',
+        // Make sure this line was added
+        aIndex: -1,
+      },
+      {
+        line: "  console.log('hello world');",
+        aIndex: -1,
+      },
+      {
+        line: '}',
+        aIndex: -1,
+      },
+    ],
+  });
+});
+
+test('should diff complex code movement effectively', () => {
+  const result = patienceDiff(
+    `void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)
+{
+    if (!Chunk_bounds_check(src, src_start, n)) return;
+    if (!Chunk_bounds_check(dst, dst_start, n)) return;
+
+    memcpy(dst->data + dst_start, src->data + src_start, n);
+}
+
+int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
+{
+    if (chunk == NULL) return 0;
+
+    return start <= chunk->length && n <= chunk->length - start;
+}`.split('\n'),
+    `int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
+{
+    if (chunk == NULL) return 0;
+
+    return start <= chunk->length && n <= chunk->length - start;
+}
+
+void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)
+{
+    if (!Chunk_bounds_check(src, src_start, n)) return;
+    if (!Chunk_bounds_check(dst, dst_start, n)) return;
+
+    memcpy(dst->data + dst_start, src->data + src_start, n);
+}`.split('\n'),
+  );
+
+  // printDiff(result);
+  /* 
+    + int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
+    + {
+    +     if (chunk == NULL) return 0;
+    + 
+    +     return start <= chunk->length && n <= chunk->length - start;
+    + }
+    + 
+      void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)
+      {
+          if (!Chunk_bounds_check(src, src_start, n)) return;
+          if (!Chunk_bounds_check(dst, dst_start, n)) return;
+      
+          memcpy(dst->data + dst_start, src->data + src_start, n);
+      }
+    -
+    - int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)
+    - {
+    -     if (chunk == NULL) return 0;
+    -
+    -     return start <= chunk->length && n <= chunk->length - start;
+    - }
+  */
+
+  expect(result).toMatchObject({
+    lines: [
+      {
+        line: 'int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)',
+        // Make sure this is the line added
+        aIndex: -1,
+      },
+      {
+        line: '{',
+        aIndex: -1,
+      },
+      {
+        line: '    if (chunk == NULL) return 0;',
+        aIndex: -1,
+      },
+      {
+        line: '',
+        aIndex: -1,
+      },
+      {
+        line: '    return start <= chunk->length && n <= chunk->length - start;',
+        aIndex: -1,
+      },
+      {
+        line: '}',
+        aIndex: -1,
+      },
+      {
+        line: '',
+      },
+      {
+        line: 'void Chunk_copy(Chunk *src, size_t src_start, Chunk *dst, size_t dst_start, size_t n)',
+      },
+      {
+        line: '{',
+      },
+      {
+        line: '    if (!Chunk_bounds_check(src, src_start, n)) return;',
+      },
+      {
+        line: '    if (!Chunk_bounds_check(dst, dst_start, n)) return;',
+      },
+      {
+        line: '',
+      },
+      {
+        line: '    memcpy(dst->data + dst_start, src->data + src_start, n);',
+      },
+      {
+        line: '}',
+      },
+      {
+        line: '',
+        bIndex: -1,
+      },
+      {
+        line: 'int Chunk_bounds_check(Chunk *chunk, size_t start, size_t n)',
+        // Make sure this is the line removed
+        bIndex: -1,
+      },
+      {
+        line: '{',
+        bIndex: -1,
+      },
+      {
+        line: '    if (chunk == NULL) return 0;',
+        bIndex: -1,
+      },
+      {
+        line: '',
+        bIndex: -1,
+      },
+      {
+        line: '    return start <= chunk->length && n <= chunk->length - start;',
+        bIndex: -1,
+      },
+      {
+        line: '}',
+        bIndex: -1,
+      },
+    ],
+  });
+});

package/src/lib/code/diff.ts

@@ -0,0 +1,319 @@
+type Subsequence = {
+  aIndex: number;
+  bIndex: number;
+  prev?: Subsequence | undefined;
+};
+
+/**
+ * Performs a patience diff on two arrays of strings, returning an object
+ * containing the lines that were deleted, inserted, and potentially moved
+ * lines. The plus parameter can result in a significant performance hit due
+ * to additional Longest Common Substring searches.
+ *
+ * @param aLines - The original array of strings
+ * @param bLines - The new array of strings
+ * @param plus - Whether to return the moved lines
+ *
+ * Adapted from Jonathan "jonTrent" Trent's patience-diff algorithm.
+ * Types and tests added by Hunter "hhenrichsen" Henrichsen.
+ *
+ * {@link https://github.com/jonTrent/PatienceDiff}
+ */
+export function patienceDiff(
+  aLines: string[],
+  bLines: string[],
+): {
+  lines: {
+    line: string;
+    aIndex: number;
+    bIndex: number;
+  }[];
+  lineCountDeleted: number;
+  lineCountInserted: number;
+} {
+  /**
+   * Finds all unique values in lines[start...end], inclusive. This
+   * function is used in preparation for determining the longest common
+   * subsequence.
+   *
+   * @param lines - The array to search
+   * @param start - The starting index (inclusive)
+   * @param end - The ending index (inclusive)
+   * @returns A map of the unique lines to their index
+   */
+  function findUnique(lines: string[], start: number, end: number) {
+    const lineMap = new Map<string, {count: number; index: number}>();
+    for (let i = start; i <= end; i++) {
+      const line = lines[i];
+      const data = lineMap.get(line);
+      if (data) {
+        data.count++;
+        data.index = i;
+      } else {
+        lineMap.set(line, {count: 1, index: i});
+      }
+    }
+
+    const newMap = new Map<string, number>();
+    for (const [key, value] of lineMap) {
+      if (value.count === 1) {
+        newMap.set(key, value.index);
+      }
+    }
+
+    return newMap;
+  }
+
+  /**
+   * Finds all the unique common entries between aArray[aStart...aEnd] and
+   * bArray[bStart...bEnd], inclusive. This function uses findUnique to pare
+   * down the aArray and bArray ranges first, before then walking the
+   * comparison between the two arrays.
+   *
+   *
+   * @param aArray - The original array
+   * @param aStart - The start of the original array to search
+   * @param aEnd - The end of the original array to search, inclusive
+   * @param bArray - The new array
+   * @param bStart - the start of the new array to search
+   * @param bEnd - The end of the new array to search, inclusive
+   * @returns a Map, with the key as the common line between aArray and
+   * bArray, with the value as an object containing the array indices of the
+   * matching uniqe lines.
+   */
+  function uniqueCommon(
+    aArray: string[],
+    aStart: number,
+    aEnd: number,
+    bArray: string[],
+    bStart: number,
+    bEnd: number,
+  ): Map<string, Subsequence> {
+    const aUnique = findUnique(aArray, aStart, aEnd);
+    const bUnique = findUnique(bArray, bStart, bEnd);
+
+    return [...aUnique.entries()].reduce<Map<string, Subsequence>>(
+      (paired, [key, value]) => {
+        const bIndex = bUnique.get(key);
+        if (bIndex !== undefined) {
+          paired.set(key, {
+            aIndex: value,
+            bIndex,
+          });
+        }
+        return paired;
+      },
+      new Map(),
+    );
+  }
+
+  /**
+   * Takes a map from the unique common lines between two arrays and determines
+   * the longest common subsequence.
+   *
+   * @see uniqueCommon
+   *
+   * @param abMap - The map of unique common lines between two arrays.
+   * @returns An array of objects containing the indices of the longest common
+   * subsequence.
+   */
+  function longestCommonSubsequence(
+    abMap: Map<string, Subsequence>,
+  ): Subsequence[] {
+    const jagged: [Subsequence][] = [];
+
+    abMap.forEach(value => {
+      let i = 0;
+      while (jagged[i] && jagged[i].at(-1)!.bIndex < value.bIndex) {
+        i++;
+      }
+
+      if (i > 0) {
+        value.prev = jagged[i - 1].at(-1);
+      }
+
+      if (!jagged[i]) {
+        jagged[i] = [value];
+      } else {
+        jagged[i].push(value);
+      }
+    });
+
+    // Pull out the longest common subsequence
+    let lcs: Subsequence[] = [];
+
+    if (jagged.length > 0) {
+      lcs = [jagged.at(-1)!.at(-1)!];
+      let cursor = lcs.at(-1);
+      while (cursor?.prev) {
+        cursor = cursor.prev;
+        lcs.push(cursor);
+      }
+    }
+
+    return lcs.reverse();
+  }
+
+  /**
+   * Keeps track of the aLines that have been deleted, are shared between aLines
+   * and bLines, and bLines that have been inserted.
+   */
+  const result: {
+    line: string;
+    aIndex: number;
+    bIndex: number;
+    moved: boolean;
+  }[] = [];
+  let deleted = 0;
+  let inserted = 0;
+
+  function addToResult(aIndex: number, bIndex: number) {
+    if (bIndex < 0) {
+      deleted++;
+    } else if (aIndex < 0) {
+      inserted++;
+    }
+    result.push({
+      line: 0 <= aIndex ? aLines[aIndex] : bLines[bIndex],
+      aIndex,
+      bIndex,
+      moved: false,
+    });
+  }
+
+  function addSubMatch(
+    aStart: number,
+    aEnd: number,
+    bStart: number,
+    bEnd: number,
+  ) {
+    // Match any lines at the beginning of aLines and bLines.
+    while (
+      aStart <= aEnd &&
+      bStart <= bEnd &&
+      aLines[aStart] === bLines[bStart]
+    ) {
+      addToResult(aStart++, bStart++);
+    }
+
+    // Match any lines at the end of aLines and bLines, but don't place them
+    // in the "result" array just yet, as the lines between these matches at
+    // the beginning and the end need to be analyzed first.
+    const aEndTemp = aEnd;
+    while (aStart <= aEnd && bStart <= bEnd && aLines[aEnd] === bLines[bEnd]) {
+      aEnd--;
+      bEnd--;
+    }
+
+    // Now, check to determine with the remaining lines in the subsequence
+    // whether there are any unique common lines between aLines and bLines.
+    //
+    // If not, add the subsequence to the result (all aLines having been
+    // deleted, and all bLines having been inserted).
+    //
+    // If there are unique common lines between aLines and bLines, then let's
+    // recursively perform the patience diff on the subsequence.
+    const uniqueCommonMap = uniqueCommon(
+      aLines,
+      aStart,
+      aEnd,
+      bLines,
+      bStart,
+      bEnd,
+    );
+
+    if (uniqueCommonMap.size === 0) {
+      while (aStart <= aEnd) {
+        addToResult(aStart++, -1);
+      }
+      while (bStart <= bEnd) {
+        addToResult(-1, bStart++);
+      }
+    } else {
+      recurseLCS(aStart, aEnd, bStart, bEnd, uniqueCommonMap);
+    }
+
+    // Finally, let's add the matches at the end to the result.
+    while (aEnd < aEndTemp) {
+      addToResult(++aEnd, ++bEnd);
+    }
+  }
+
+  /**
+   * Finds the longest common subsequence between the arrays
+   * aLines[aStart...aEnd] and bLines[bStart...bEnd], inclusive. Then for each
+   * subsequence, recursively performs another LCS search (via addSubMatch),
+   * until there are none found, at which point the subsequence is dumped to
+   * the result.
+   *
+   * @param aStart - The start of the original array to search
+   * @param aEnd - The end of the original array to search, inclusive
+   * @param bStart - The start of the new array to search
+   * @param bEnd - The end of the new array to search, inclusive
+   * @param uniqueCommonMap - A map of the unique common lines between
+   * aLines[aStart...aEnd] and bLines[bStart...bEnd], inclusive.
+   */
+  function recurseLCS(
+    aStart: number,
+    aEnd: number,
+    bStart: number,
+    bEnd: number,
+    uniqueCommonMap: Map<string, Subsequence> = uniqueCommon(
+      aLines,
+      aStart,
+      aEnd,
+      bLines,
+      bStart,
+      bEnd,
+    ),
+  ) {
+    const lcs = longestCommonSubsequence(uniqueCommonMap);
+
+    if (lcs.length === 0) {
+      addSubMatch(aStart, aEnd, bStart, bEnd);
+    } else {
+      if (aStart < lcs[0].aIndex || bStart < lcs[0].bIndex) {
+        addSubMatch(aStart, lcs[0].aIndex - 1, bStart, lcs[0].bIndex - 1);
+      }
+
+      let i;
+      for (i = 0; i < lcs.length - 1; i++) {
+        addSubMatch(
+          lcs[i].aIndex,
+          lcs[i + 1].aIndex - 1,
+          lcs[i].bIndex,
+          lcs[i + 1].bIndex - 1,
+        );
+      }
+
+      if (lcs[i].aIndex <= aEnd || lcs[i].bIndex <= bEnd) {
+        addSubMatch(lcs[i].aIndex, aEnd, lcs[i].bIndex, bEnd);
+      }
+    }
+  }
+
+  recurseLCS(0, aLines.length - 1, 0, bLines.length - 1);
+
+  return {
+    lines: result,
+    lineCountDeleted: deleted,
+    lineCountInserted: inserted,
+  };
+}
+
+/**
+ * Utility function for debugging patienceDiff.
+ *
+ * @internal
+ */
+export function printDiff(diff: ReturnType<typeof patienceDiff>) {
+  diff.lines.forEach(line => {
+    if (line.bIndex < 0) {
+      console.log(`- ${line.line}`);
+    } else if (line.aIndex < 0) {
+      console.log(`+ ${line.line}`);
+    } else {
+      console.log(`  ${line.line}`);
+    }
+  });
+}