From 87cefe1dedb57e5de7f784c9b847217386338b54 Mon Sep 17 00:00:00 2001 From: lionel-rowe Date: Wed, 18 Sep 2024 11:36:39 +0800 Subject: [PATCH] Refactor and reorganize for v0.1 --- deno.jsonc | 2 +- {tests => src}/Differ.test.ts | 6 ++-- src/Differ.ts | 30 +++++++++++-------- src/{DiffMatchPatch.ts => _DiffMatchPatch.ts} | 6 ++-- .../_SegmentCodec.test.ts | 2 +- src/{SegmentCodec.ts => _SegmentCodec.ts} | 4 +-- .../_full}/DiffMatchPatchFull.test.ts | 10 +++---- src/{ => _full}/DiffMatchPatchFull.ts | 4 +-- src/{ => _full}/Patch.ts | 4 +-- tests/testUtils.ts => src/_testUtils.ts | 2 +- src/utils.ts | 10 ++----- 11 files changed, 40 insertions(+), 40 deletions(-) rename {tests => src}/Differ.test.ts (96%) rename src/{DiffMatchPatch.ts => _DiffMatchPatch.ts} (99%) rename tests/SegmentCodec.test.ts => src/_SegmentCodec.test.ts (93%) rename src/{SegmentCodec.ts => _SegmentCodec.ts} (92%) rename {tests => src/_full}/DiffMatchPatchFull.test.ts (99%) rename src/{ => _full}/DiffMatchPatchFull.ts (99%) rename src/{ => _full}/Patch.ts (93%) rename tests/testUtils.ts => src/_testUtils.ts (86%) diff --git a/deno.jsonc b/deno.jsonc index 00e7158..18070f9 100644 --- a/deno.jsonc +++ b/deno.jsonc @@ -10,7 +10,7 @@ "./utils": "./src/utils.ts" }, "tasks": { - "test": "deno test --doc src tests" + "test": "deno test --doc src" }, "imports": { "@clearlylocal/diff-match-patch-unicode": "./src/mod.ts", diff --git a/tests/Differ.test.ts b/src/Differ.test.ts similarity index 96% rename from tests/Differ.test.ts rename to src/Differ.test.ts index 7964907..8b0d120 100644 --- a/tests/Differ.test.ts +++ b/src/Differ.test.ts @@ -1,7 +1,7 @@ import { assertEquals } from '@std/assert' -import { Differ, segmenters } from '../src/Differ.ts' -import { assertDiffsEqual, assertDiffsEqual2d } from './testUtils.ts' -import { DiffMatchPatchFull } from '../src/DiffMatchPatchFull.ts' +import { Differ, segmenters } from './Differ.ts' +import { assertDiffsEqual, assertDiffsEqual2d } from './_testUtils.ts' +import { DiffMatchPatchFull } from './_full/DiffMatchPatchFull.ts' const differ = new Differ() diff --git a/src/Differ.ts b/src/Differ.ts index 5ecd37d..58cc27d 100644 --- a/src/Differ.ts +++ b/src/Differ.ts @@ -1,6 +1,6 @@ import { Diff, DiffOperation } from './Diff.ts' -import { DiffMatchPatch, MAX_SEGMENTS, MAX_SEGMENTS_2_3 } from './DiffMatchPatch.ts' -import { SegmentCodec, StringIter } from './SegmentCodec.ts' +import { DiffMatchPatch, MAX_SEGMENTS, MAX_SEGMENTS_2_3 } from './_DiffMatchPatch.ts' +import { SegmentCodec, StringIter } from './_SegmentCodec.ts' /** * Instance-level configuration options for the {@linkcode Differ} class to pass to the underlying @@ -23,7 +23,9 @@ export type DiffOptions = { */ segmenter: Segmenter /** - * Whether to join adjacent diffs. + * Whether to count consecutive diff operations containing multiple segments as a single diff. + * If `true`, a diff may contain multiple segments; if `false`, each segment will be a separate diff. + * * @default {true} */ join: boolean @@ -81,15 +83,18 @@ export class Differ { } } - #diffInternal(before: string, after: string, options: DiffOptions, maxBefore: number, maxAfter: number): { + #diffInternal(before: string, after: string, options: DiffOptions & { maxBefore: number; maxAfter: number }): { encodedDiffs: Diff[] - codec?: SegmentCodec + decode: (encoded: string) => string[] } { - const { segmenter, checkLines } = options + const { segmenter, checkLines, join, maxBefore, maxAfter } = options // if no surrogate pairs present, we're entirely within the BMP, so no need to encode if (segmenter === segmenters.char && !/[\uD800-\uDBFF]/.test([before, after].join(''))) { - return { encodedDiffs: this.#dmp.diff_main(before, after, checkLines, this.#deadline) } + return { + encodedDiffs: this.#dmp.diff_main(before, after, checkLines, this.#deadline), + decode: join ? (x) => [x] : (x) => x.split(''), + } } const segment = this.#toSegmentFn(segmenter) @@ -101,7 +106,7 @@ export class Differ { const encodedDiffs = this.#dmp.diff_main(chars1, chars2, checkLines, this.#deadline) - return { encodedDiffs, codec } + return { encodedDiffs, decode: codec.decode.bind(codec) } } /** @@ -137,19 +142,18 @@ export class Differ { return before ? [new Diff(DiffOperation.Equal, before)] : [] } - const opts = { ...defaultDiffOptions, ...options } + const opts = { ...defaultDiffOptions, ...options, maxBefore: MAX_SEGMENTS_2_3, maxAfter: MAX_SEGMENTS } const { join } = opts - const { encodedDiffs, codec } = this.#diffInternal(before, after, opts, MAX_SEGMENTS_2_3, MAX_SEGMENTS) - if (codec == null) return encodedDiffs + const { encodedDiffs, decode } = this.#diffInternal(before, after, opts) if (!join) { return encodedDiffs.flatMap( - ({ op, text }) => codec.decode(text).filter(Boolean).map((segment) => new Diff(op, segment)), + ({ op, text }) => decode(text).filter(Boolean).map((segment) => new Diff(op, segment)), ) } - return encodedDiffs.map(({ op, text }) => new Diff(op, codec.decode(text).join(''))).filter((x) => x.text) + return encodedDiffs.map(({ op, text }) => new Diff(op, decode(text).join(''))).filter((x) => x.text) } /** diff --git a/src/DiffMatchPatch.ts b/src/_DiffMatchPatch.ts similarity index 99% rename from src/DiffMatchPatch.ts rename to src/_DiffMatchPatch.ts index e869c9b..92f1d5c 100644 --- a/src/DiffMatchPatch.ts +++ b/src/_DiffMatchPatch.ts @@ -1,6 +1,6 @@ import { Diff, DiffOperation } from './Diff.ts' -// reduced version - removed props/methods that are currently unused by `Differ` +// reduced version - removed props/methods that are currently unused by `Differ` class /** * Diff Match and Patch @@ -26,9 +26,9 @@ import { Diff, DiffOperation } from './Diff.ts' * @author fraser@google.com (Neil Fraser) */ -// max BMP code point. hard limit w/o significant refactoring +/** `0xFFFF`: Max BMP code point. Hard limit w/o significant refactoring */ export const MAX_SEGMENTS = 0xFFFF -// round(MAX_SEGMENTS * 2 / 3) +/** `= round(MAX_SEGMENTS * 2 / 3)` */ export const MAX_SEGMENTS_2_3 = 0xAAAA /** diff --git a/tests/SegmentCodec.test.ts b/src/_SegmentCodec.test.ts similarity index 93% rename from tests/SegmentCodec.test.ts rename to src/_SegmentCodec.test.ts index 5b49d37..33a7838 100644 --- a/tests/SegmentCodec.test.ts +++ b/src/_SegmentCodec.test.ts @@ -1,6 +1,6 @@ import { AssertionError } from '@std/assert/assertion-error' import { assertEquals, assertThrows } from '@std/assert' -import { SegmentCodec } from '../src/SegmentCodec.ts' +import { SegmentCodec } from './_SegmentCodec.ts' Deno.test(SegmentCodec.name, async (t) => { await t.step('happy path', () => { diff --git a/src/SegmentCodec.ts b/src/_SegmentCodec.ts similarity index 92% rename from src/SegmentCodec.ts rename to src/_SegmentCodec.ts index 94ea4c5..6a50022 100644 --- a/src/SegmentCodec.ts +++ b/src/_SegmentCodec.ts @@ -50,7 +50,7 @@ export class SegmentCodec { return out } - decode(text: string): string[] { - return [...text].map((char) => this.#decoded.get(char) ?? '') + decode(encoded: string): string[] { + return [...encoded].map((char) => this.#decoded.get(char) ?? '') } } diff --git a/tests/DiffMatchPatchFull.test.ts b/src/_full/DiffMatchPatchFull.test.ts similarity index 99% rename from tests/DiffMatchPatchFull.test.ts rename to src/_full/DiffMatchPatchFull.test.ts index feb1816..226a113 100644 --- a/tests/DiffMatchPatchFull.test.ts +++ b/src/_full/DiffMatchPatchFull.test.ts @@ -1,9 +1,9 @@ import { assert, assertEquals } from '@std/assert' -import { DiffMatchPatchFull as DiffMatchPatch } from '../src/DiffMatchPatchFull.ts' -import { Diff, DiffOperation } from '../src/Diff.ts' -import { Patch } from '../src/Patch.ts' -import { assertDiffsEqual } from './testUtils.ts' -import { makeDiffs } from '../src/utils.ts' +import { DiffMatchPatchFull as DiffMatchPatch } from './DiffMatchPatchFull.ts' +import { Diff, DiffOperation } from '../Diff.ts' +import { Patch } from './Patch.ts' +import { assertDiffsEqual } from '../_testUtils.ts' +import { makeDiffs } from '../utils.ts' // Tests here are modified from `google/diff-match-patch` tests // to ensure parity after the various refactoring (ESM, classes, TS, etc.) diff --git a/src/DiffMatchPatchFull.ts b/src/_full/DiffMatchPatchFull.ts similarity index 99% rename from src/DiffMatchPatchFull.ts rename to src/_full/DiffMatchPatchFull.ts index d7503e1..dcbe114 100644 --- a/src/DiffMatchPatchFull.ts +++ b/src/_full/DiffMatchPatchFull.ts @@ -1,5 +1,5 @@ -import { Diff, DiffOperation } from './Diff.ts' -import { DiffMatchPatch } from './DiffMatchPatch.ts' +import { Diff, DiffOperation } from '../Diff.ts' +import { DiffMatchPatch } from '../_DiffMatchPatch.ts' import { Patch } from './Patch.ts' // full version (extending reduced version) - re-add props/methods that are currently unused by `Differ` diff --git a/src/Patch.ts b/src/_full/Patch.ts similarity index 93% rename from src/Patch.ts rename to src/_full/Patch.ts index 124b0c0..87d9d64 100644 --- a/src/Patch.ts +++ b/src/_full/Patch.ts @@ -1,5 +1,5 @@ -import { DiffOperation } from './Diff.ts' -import type { Diff } from './Diff.ts' +import { DiffOperation } from '../Diff.ts' +import type { Diff } from '../Diff.ts' /** * Class representing one patch operation. diff --git a/tests/testUtils.ts b/src/_testUtils.ts similarity index 86% rename from tests/testUtils.ts rename to src/_testUtils.ts index 8a1fd20..5bac5d7 100644 --- a/tests/testUtils.ts +++ b/src/_testUtils.ts @@ -1,5 +1,5 @@ import { assertEquals } from '@std/assert/equals' -import { DiffLike, makeDiffs } from '../src/utils.ts' +import { DiffLike, makeDiffs } from './utils.ts' export function assertDiffsEqual(d1: readonly DiffLike[], d2: readonly DiffLike[]) { assertEquals(makeDiffs(d1), makeDiffs(d2)) diff --git a/src/utils.ts b/src/utils.ts index 9b28235..15268a4 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -1,5 +1,5 @@ +import { Diff, DiffOperation } from './Diff.ts' import { assert } from '@std/assert/assert' -import { Diff, type DiffOperation } from './Diff.ts' /** * A `Diff` or a tuple of `[operation, text]` (loosely typed for convenience as an input to `makeDiff`). @@ -20,10 +20,6 @@ export function makeDiff(d: DiffLike): Diff { if (d instanceof Diff) return d const [op, text] = d assert(typeof text === 'string') - return new Diff(getOpWithAssertion(op), text) -} - -function getOpWithAssertion(op: unknown): DiffOperation { - assert(op === -1 || op === 0 || op === 1) - return op + assert(op === DiffOperation.Delete || op === DiffOperation.Insert || op === DiffOperation.Equal) + return new Diff(op, text) }