@twick/2d 0.14.0 → 1.14.3

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

@@ -1,311 +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,
-      },
-    ],
-  });
-});
+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,
+      },
+    ],
+  });
+});