reslop 0.2.4 → 0.2.6

package/lib/diff/inline.js

@@ -6,6 +6,7 @@ const { graphemes } = ansi;
 const LCS_CELL_LIMIT = 250000;
 const NOISY_TINY_SPANS = 6;
 const WORD_REFINE_MIN = 0.6;
+const WHOLE_MIN_SHARED = 0.25;
 const PIECE_RE = /[A-Za-z_$][\w$]*|\d+|\s+|./g;
 const CAMEL_RE = /[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|\d+|./g;
 
@@ -35,19 +36,24 @@ const wholeChanged = (a, b) => ({
   newSpans: b.length ? [{ text: b.join(''), changed: true }] : [],
 });
 
+const sharedEnds = (a, b) => {
+  let lo = 0;
+  while (lo < a.length && lo < b.length && a[lo] === b[lo]) lo += 1;
+  let hiA = a.length;
+  let hiB = b.length;
+  while (hiA > lo && hiB > lo && a[hiA - 1] === b[hiB - 1]) {
+    hiA -= 1;
+    hiB -= 1;
+  }
+  return { lo, hiA, hiB };
+};
+
 const lcsLength = (a, b) => {
   const n = a.length;
   const m = b.length;
   if (n === 0 || m === 0) return 0;
   if (n * m > LCS_CELL_LIMIT) {
-    let lo = 0;
-    while (lo < n && lo < m && a[lo] === b[lo]) lo += 1;
-    let hiA = n;
-    let hiB = m;
-    while (hiA > lo && hiB > lo && a[hiA - 1] === b[hiB - 1]) {
-      hiA -= 1;
-      hiB -= 1;
-    }
+    const { lo, hiA } = sharedEnds(a, b);
     return lo + (n - hiA);
   }
   let prev = new Uint32Array(m + 1);
@@ -73,7 +79,7 @@ const tokenSimilarity = (a, b) => {
   return (2 * lcs) / (a.length + b.length);
 };
 
-const fillLcsTable = (a, b) => {
+const lcsTable = (a, b) => {
   const n = a.length;
   const m = b.length;
   const dp = new Array(n + 1);
@@ -90,7 +96,8 @@ const fillLcsTable = (a, b) => {
   return dp;
 };
 
-const tracebackLcs = (a, b, dp) => {
+const lcsOps = (a, b) => {
+  const dp = lcsTable(a, b);
   const rev = new Array(a.length + b.length - dp[a.length][b.length]);
   let n = 0;
   let i = a.length;
@@ -100,44 +107,29 @@ const tracebackLcs = (a, b, dp) => {
       rev[n++] = { type: 'eq', text: a[i - 1] };
       i -= 1;
       j -= 1;
-      continue;
-    }
-    if (dp[i - 1][j] >= dp[i][j - 1]) {
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
       rev[n++] = { type: 'del', text: a[i - 1] };
       i -= 1;
-      continue;
+    } else {
+      rev[n++] = { type: 'add', text: b[j - 1] };
+      j -= 1;
     }
-    rev[n++] = { type: 'add', text: b[j - 1] };
-    j -= 1;
   }
-  while (i > 0) {
-    rev[n++] = { type: 'del', text: a[i - 1] };
-    i -= 1;
-  }
-  while (j > 0) {
-    rev[n++] = { type: 'add', text: b[j - 1] };
-    j -= 1;
-  }
-  rev.reverse();
-  return rev;
+  for (; i > 0; i--) rev[n++] = { type: 'del', text: a[i - 1] };
+  for (; j > 0; j--) rev[n++] = { type: 'add', text: b[j - 1] };
+  return rev.reverse();
 };
 
-const lcsOps = (a, b) => tracebackLcs(a, b, fillLcsTable(a, b));
-
-const lcsSpans = (a, b) => {
+const opsSpans = (ops) => {
   const oldParts = [];
   const newParts = [];
-  for (const op of lcsOps(a, b)) {
-    if (op.type === 'eq') {
-      oldParts.push({ text: op.text, changed: false });
-      newParts.push({ text: op.text, changed: false });
-      continue;
+  for (const op of ops) {
+    if (op.type !== 'add') {
+      oldParts.push({ text: op.text, changed: op.type === 'del' });
     }
-    if (op.type === 'del') {
-      oldParts.push({ text: op.text, changed: true });
-      continue;
+    if (op.type !== 'del') {
+      newParts.push({ text: op.text, changed: op.type === 'add' });
     }
-    newParts.push({ text: op.text, changed: true });
   }
   return {
     oldSpans: collapseSpans(oldParts),
@@ -145,67 +137,35 @@ const lcsSpans = (a, b) => {
   };
 };
 
-const trimSharedEnds = (a, b) => {
-  let lo = 0;
-  while (lo < a.length && lo < b.length && a[lo] === b[lo]) lo += 1;
-  let hiA = a.length;
-  let hiB = b.length;
-  while (hiA > lo && hiB > lo && a[hiA - 1] === b[hiB - 1]) {
-    hiA -= 1;
-    hiB -= 1;
-  }
-  return {
-    prefix: a.slice(0, lo),
-    suffix: a.slice(hiA),
-    midA: a.slice(lo, hiA),
-    midB: b.slice(lo, hiB),
-  };
-};
-
-const diffTokenMiddle = (midA, midB) => {
-  if (midA.length * midB.length > LCS_CELL_LIMIT) {
-    return wholeChanged(midA, midB);
-  }
-  if (midA.length === 0 && midB.length === 0) {
-    return { oldSpans: [], newSpans: [] };
-  }
-  if (midA.length === 0 || midB.length === 0) return wholeChanged(midA, midB);
-  return lcsSpans(midA, midB);
-};
-
 const joinAffix = (prefix, mid, suffix) => {
-  const hasPrefix = prefix.length > 0;
-  const hasSuffix = suffix.length > 0;
-  const extra = (hasPrefix ? 1 : 0) + (hasSuffix ? 1 : 0);
-  const parts = new Array(mid.length + extra);
-  const at = hasPrefix ? 1 : 0;
-  if (hasPrefix) {
-    parts[0] = { text: prefix.join(''), changed: false };
-  }
-  for (let i = 0; i < mid.length; i++) parts[at + i] = mid[i];
-  if (hasSuffix) {
-    parts[at + mid.length] = { text: suffix.join(''), changed: false };
-  }
+  const parts = [];
+  if (prefix.length) parts.push({ text: prefix.join(''), changed: false });
+  for (const span of mid) parts.push(span);
+  if (suffix.length) parts.push({ text: suffix.join(''), changed: false });
   return collapseSpans(parts);
 };
 
-const joinTrimmedSpans = (prefix, mid, suffix) => ({
-  oldSpans: joinAffix(prefix, mid.oldSpans, suffix),
-  newSpans: joinAffix(prefix, mid.newSpans, suffix),
-});
+const diffTrimmed = (a, b, spansOfOps) => {
+  const { lo, hiA, hiB } = sharedEnds(a, b);
+  const midA = a.slice(lo, hiA);
+  const midB = b.slice(lo, hiB);
+  const tooBig = midA.length * midB.length > LCS_CELL_LIMIT;
+  const whole = !midA.length || !midB.length || tooBig;
+  const mid = whole ? wholeChanged(midA, midB) : spansOfOps(lcsOps(midA, midB));
+  const prefix = a.slice(0, lo);
+  const suffix = a.slice(hiA);
+  return {
+    oldSpans: joinAffix(prefix, mid.oldSpans, suffix),
+    newSpans: joinAffix(prefix, mid.newSpans, suffix),
+  };
+};
 
 const diffTokens = (a, b) => {
-  if (a.length === 0 && b.length === 0) {
-    return { oldSpans: [], newSpans: [] };
-  }
-  if (a.length === 0 || b.length === 0) return wholeChanged(a, b);
-  const trimmed = trimSharedEnds(a, b);
-  const mid = diffTokenMiddle(trimmed.midA, trimmed.midB);
-  const joined = joinTrimmedSpans(trimmed.prefix, mid, trimmed.suffix);
-  if (isNoisy(joined.oldSpans) || isNoisy(joined.newSpans)) {
+  const spans = diffTrimmed(a, b, opsSpans);
+  if (isNoisy(spans.oldSpans) || isNoisy(spans.newSpans)) {
     return wholeChanged(a, b);
   }
-  return joined;
+  return spans;
 };
 
 const splitCamel = (part) => {
@@ -213,31 +173,23 @@ const splitCamel = (part) => {
   return part.match(CAMEL_RE) ?? [part];
 };
 
-const splitIdentWords = (part) => {
-  const words = [];
-  for (const chunk of part.split(/(_+)/)) {
-    if (chunk === '') continue;
-    if (chunk.includes('_')) {
-      words.push(chunk);
-      continue;
-    }
-    for (const word of splitCamel(chunk)) words.push(word);
-  }
-  return words;
-};
-
 const splitPieces = (text) => {
-  if (text === '') return [];
   PIECE_RE.lastIndex = 0;
-  const coarse = text.match(PIECE_RE) ?? [];
   const pieces = [];
-  for (const part of coarse) {
-    for (const word of splitIdentWords(part)) pieces.push(word);
+  for (const part of text.match(PIECE_RE) ?? []) {
+    for (const chunk of part.split(/(_+)/)) {
+      if (chunk === '') continue;
+      if (chunk.includes('_')) {
+        pieces.push(chunk);
+        continue;
+      }
+      for (const word of splitCamel(chunk)) pieces.push(word);
+    }
   }
   return pieces;
 };
 
-const spansFromWordOps = (ops) => {
+const refineWordOps = (ops) => {
   const oldParts = [];
   const newParts = [];
   let i = 0;
@@ -256,23 +208,18 @@ const spansFromWordOps = (ops) => {
       else adds.push(ops[i].text);
       i += 1;
     }
-    const one = dels.length === 1 && adds.length === 1;
-    const close =
-      one &&
-      tokenSimilarity(graphemes(dels[0]), graphemes(adds[0])) >=
-        WORD_REFINE_MIN;
-    if (close) {
-      const inner = diffTokens(graphemes(dels[0]), graphemes(adds[0]));
-      for (const span of inner.oldSpans) oldParts.push(span);
-      for (const span of inner.newSpans) newParts.push(span);
-      continue;
-    }
-    if (dels.length) {
-      oldParts.push({ text: dels.join(''), changed: true });
-    }
-    if (adds.length) {
-      newParts.push({ text: adds.join(''), changed: true });
+    if (dels.length === 1 && adds.length === 1) {
+      const delChars = graphemes(dels[0]);
+      const addChars = graphemes(adds[0]);
+      if (tokenSimilarity(delChars, addChars) >= WORD_REFINE_MIN) {
+        const inner = diffTokens(delChars, addChars);
+        for (const span of inner.oldSpans) oldParts.push(span);
+        for (const span of inner.newSpans) newParts.push(span);
+        continue;
+      }
     }
+    if (dels.length) oldParts.push({ text: dels.join(''), changed: true });
+    if (adds.length) newParts.push({ text: adds.join(''), changed: true });
   }
   return {
     oldSpans: collapseSpans(oldParts),
@@ -280,26 +227,76 @@ const spansFromWordOps = (ops) => {
   };
 };
 
+const opRuns = (ops) => {
+  const runs = [];
+  for (const op of ops) {
+    const eq = op.type === 'eq';
+    let run = runs[runs.length - 1];
+    if (!run || run.eq !== eq) {
+      run = { eq, del: [], add: [] };
+      runs.push(run);
+    }
+    if (op.type !== 'add') run.del.push(op.text);
+    if (op.type !== 'del') run.add.push(op.text);
+  }
+  return runs;
+};
+
+const textSize = (parts) => parts.join('').length;
+
+const editSize = (run) => Math.max(textSize(run.del), textSize(run.add));
+
+const absorbTinyEquals = (runs) => {
+  for (let k = 1; k < runs.length - 1; k++) {
+    const before = runs[k - 1];
+    const eq = runs[k];
+    const after = runs[k + 1];
+    if (!eq.eq) continue;
+    const size = textSize(eq.del);
+    if (size > editSize(before) || size > editSize(after)) continue;
+    const del = [...before.del, ...eq.del, ...after.del];
+    const add = [...before.add, ...eq.add, ...after.add];
+    runs.splice(k - 1, 3, { eq: false, del, add });
+    k = 0;
+  }
+  return runs;
+};
+
+const runOps = (runs) => {
+  const ops = [];
+  for (const run of runs) {
+    if (run.eq) {
+      for (const text of run.del) ops.push({ type: 'eq', text });
+      continue;
+    }
+    for (const text of run.del) ops.push({ type: 'del', text });
+    for (const text of run.add) ops.push({ type: 'add', text });
+  }
+  return ops;
+};
+
+const wordSpans = (ops) => refineWordOps(runOps(absorbTinyEquals(opRuns(ops))));
+
+const sharedShare = (spans) => {
+  let shared = 0;
+  let total = 0;
+  for (const span of spans) {
+    const size = span.text.replace(/\s/g, '').length;
+    total += size;
+    if (!span.changed) shared += size;
+  }
+  return total === 0 ? 1 : shared / total;
+};
+
 const diffChars = (oldText, newText) => {
   const a = splitPieces(oldText);
   const b = splitPieces(newText);
-  if (a.length === 0 && b.length === 0) {
-    return { oldSpans: [], newSpans: [] };
-  }
-  if (a.length === 0 || b.length === 0) return wholeChanged(a, b);
-  const { prefix, suffix, midA, midB } = trimSharedEnds(a, b);
-  let mid;
-  if (midA.length === 0 && midB.length === 0) {
-    mid = { oldSpans: [], newSpans: [] };
-  } else if (midA.length === 0 || midB.length === 0) {
-    mid = wholeChanged(midA, midB);
-  } else if (midA.length * midB.length > LCS_CELL_LIMIT) {
-    mid = wholeChanged(midA, midB);
-  } else {
-    mid = spansFromWordOps(lcsOps(midA, midB));
+  const { oldSpans, newSpans } = diffTrimmed(a, b, wordSpans);
+  const oldShare = sharedShare(oldSpans);
+  const newShare = sharedShare(newSpans);
+  if (oldShare < WHOLE_MIN_SHARED && newShare < WHOLE_MIN_SHARED) {
+    return wholeChanged(a, b);
   }
-  const oldSpans = joinAffix(prefix, mid.oldSpans, suffix);
-  const newSpans = joinAffix(prefix, mid.newSpans, suffix);
   return { oldSpans, newSpans };
 };
 

package/lib/diff/items.js

@@ -3,36 +3,34 @@
 const patch = require('./patch.js');
 const { splitHunk, formatHunkHeader, formatPatch } = patch;
 
-const INDEX_SIDE = {
-  staged: 'new',
-  unstaged: 'old',
-  untracked: 'old',
-  commit: 'old',
-  pr: 'old',
+const BINARY_ITEM = {
+  hunk: null,
+  blockId: null,
+  patchAdd: '',
+  patchRevert: '',
 };
 
-const splitLines = (content) => {
-  if (content === '') return { lines: [''], noNl: true };
-  const parts = content.split('\n');
-  const noNl = parts.at(-1) !== '';
-  if (!noNl) parts.pop();
-  return { lines: parts, noNl };
-};
+const indexSide = (origin) => (origin === 'staged' ? 'new' : 'old');
 
 const synthesizeNewFile = (relPath, content) => {
-  const { lines, noNl } = splitLines(content);
-  const body = lines.map((text, index) => ({
+  const noNl = content === '' || !content.endsWith('\n');
+  const texts = noNl ? content.split('\n') : content.slice(0, -1).split('\n');
+  const lines = texts.map((text, index) => ({
     type: 'add',
     text,
-    noNl: noNl && index === lines.length - 1,
+    noNl: noNl && index === texts.length - 1,
     blockId: 0,
   }));
-  const oldStart = 0;
-  const oldCount = 0;
-  const newStart = 1;
-  const newCount = body.length;
-  const header = formatHunkHeader(oldStart, oldCount, newStart, newCount);
-  const hunk = { oldStart, oldCount, newStart, newCount, header, lines: body };
+  const newCount = lines.length;
+  const header = formatHunkHeader(0, 0, 1, newCount);
+  const hunk = {
+    oldStart: 0,
+    oldCount: 0,
+    newStart: 1,
+    newCount,
+    header,
+    lines,
+  };
   const preamble = [
     `diff --git a/${relPath} b/${relPath}`,
     'new file mode 100644',
@@ -52,21 +50,16 @@ const synthesizeNewFile = (relPath, content) => {
 
 const itemsFromFiles = (files, origin) => {
   const items = [];
+  const side = indexSide(origin);
   for (const file of files) {
     if (file.isBinary) {
-      const hunk = null;
-      const blockId = null;
-      const patchAdd = '';
-      const patchRevert = '';
-      items.push({ origin, file, hunk, blockId, patchAdd, patchRevert });
+      items.push({ origin, file, ...BINARY_ITEM });
       continue;
     }
     for (const rawHunk of file.hunks) {
       const { hunk, blocks } = splitHunk(rawHunk);
-      for (const block of blocks) {
-        const blockId = block.id;
-        const indexSide = INDEX_SIDE[origin] ?? 'old';
-        const patchAdd = formatPatch(file, hunk, blockId, indexSide);
+      for (const { id: blockId } of blocks) {
+        const patchAdd = formatPatch(file, hunk, blockId, side);
         const patchRevert = formatPatch(file, hunk, blockId, 'new');
         items.push({ origin, file, hunk, blockId, patchAdd, patchRevert });
       }
@@ -76,24 +69,17 @@ const itemsFromFiles = (files, origin) => {
 };
 
 const refreshIndexPatches = (items, item) => {
-  if (!item.hunk || !item.file) return items;
+  if (!item.hunk) return items;
+  const isPeer = (other) =>
+    other.hunk === item.hunk && other.file === item.file;
+  const peers = items.filter(isPeer);
   const sides = {};
-  for (const other of items) {
-    if (other.hunk !== item.hunk || other.file !== item.file) continue;
-    sides[other.blockId] = INDEX_SIDE[other.origin] ?? 'old';
-  }
-  const { length } = items;
-  const next = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const other = items[i];
-    if (other.hunk !== item.hunk || other.file !== item.file) {
-      next[i] = other;
-      continue;
-    }
+  for (const peer of peers) sides[peer.blockId] = indexSide(peer.origin);
+  return items.map((other) => {
+    if (!isPeer(other)) return other;
     const patchAdd = formatPatch(other.file, other.hunk, other.blockId, sides);
-    next[i] = { ...other, patchAdd };
-  }
-  return next;
+    return { ...other, patchAdd };
+  });
 };
 
 module.exports = {

package/lib/diff/parse.js

@@ -1,57 +1,34 @@
 'use strict';
 
-const LINE_TYPE = {
-  '+': 'add',
-  '-': 'del',
-  ' ': 'ctx',
-};
+const LINE_TYPE = { '+': 'add', '-': 'del', ' ': 'ctx' };
+
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
 
 const parseGitPaths = (line) => {
   const rest = line.slice('diff --git '.length);
   const mid = rest.lastIndexOf(' b/');
   if (mid < 0 || !rest.startsWith('a/')) return { oldPath: '', newPath: '' };
-  const oldPath = rest.slice(2, mid);
-  const newPath = rest.slice(mid + 3);
-  return { oldPath, newPath };
-};
-
-const stripAb = (raw) => {
-  if (raw === '/dev/null') return raw;
-  if (raw.startsWith('a/') || raw.startsWith('b/')) return raw.slice(2);
-  return raw;
+  return { oldPath: rest.slice(2, mid), newPath: rest.slice(mid + 3) };
 };
 
 const parsePathLine = (line) => {
   const space = line.indexOf(' ');
   if (space < 0) return '';
   let rest = line.slice(space + 1);
-  if (rest.startsWith('"') && rest.endsWith('"')) {
-    rest = rest.slice(1, -1);
-  }
+  if (rest.startsWith('"') && rest.endsWith('"')) rest = rest.slice(1, -1);
   const tab = rest.indexOf('\t');
   if (tab >= 0) rest = rest.slice(0, tab);
-  return stripAb(rest);
+  if (rest.startsWith('a/') || rest.startsWith('b/')) return rest.slice(2);
+  return rest;
 };
 
-const parseHunkHeader = (line) => {
-  const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/.exec(line);
-  if (!match) return null;
-  const oldStart = parseInt(match[1], 10);
-  const oldCount = match[2] === undefined ? 1 : parseInt(match[2], 10);
-  const newStart = parseInt(match[3], 10);
-  const newCount = match[4] === undefined ? 1 : parseInt(match[4], 10);
-  return { oldStart, oldCount, newStart, newCount, header: line };
-};
-
-const closeFile = (file, files) => {
-  if (file) files.push(file);
-};
+const parseCount = (text) => (text === undefined ? 1 : parseInt(text, 10));
 
-const createFile = (line) => {
-  const paths = parseGitPaths(line);
-  return {
-    oldPath: paths.oldPath,
-    newPath: paths.newPath,
+const startGitFile = (line, ctx) => {
+  if (ctx.file) ctx.files.push(ctx.file);
+  ctx.hunk = null;
+  ctx.file = {
+    ...parseGitPaths(line),
     isNew: false,
     isDeleted: false,
     isBinary: false,
@@ -60,12 +37,6 @@ const createFile = (line) => {
   };
 };
 
-const startGitFile = (line, ctx) => {
-  ctx.hunk = null;
-  closeFile(ctx.file, ctx.files);
-  ctx.file = createFile(line);
-};
-
 const markBinary = (line, ctx) => {
   ctx.file.isBinary = true;
   ctx.file.preamble.push(line);
@@ -97,9 +68,16 @@ const setNewPath = (line, ctx) => {
 };
 
 const startHunk = (line, ctx) => {
-  const meta = parseHunkHeader(line);
-  if (!meta) return;
-  ctx.hunk = { ...meta, lines: [] };
+  const match = HUNK_RE.exec(line);
+  if (!match) return;
+  ctx.hunk = {
+    oldStart: parseInt(match[1], 10),
+    oldCount: parseCount(match[2]),
+    newStart: parseInt(match[3], 10),
+    newCount: parseCount(match[4]),
+    header: line,
+    lines: [],
+  };
   ctx.file.hunks.push(ctx.hunk);
 };
 
@@ -121,11 +99,8 @@ const takeHunkLine = (line, hunk) => {
     return;
   }
   const type = LINE_TYPE[line[0]];
-  if (type) {
-    hunk.lines.push({ type, text: line.slice(1), noNl: false });
-    return;
-  }
-  hunk.lines.push({ type: 'ctx', text: line, noNl: false });
+  const text = type ? line.slice(1) : line;
+  hunk.lines.push({ type: type ?? 'ctx', text, noNl: false });
 };
 
 const parseDiff = (text) => {
@@ -143,13 +118,10 @@ const parseDiff = (text) => {
       continue;
     }
     if (!ctx.file) continue;
-    if (!ctx.hunk) {
-      ctx.file.preamble.push(line);
-      continue;
-    }
-    takeHunkLine(line, ctx.hunk);
+    if (ctx.hunk) takeHunkLine(line, ctx.hunk);
+    else ctx.file.preamble.push(line);
   }
-  closeFile(ctx.file, files);
+  if (ctx.file) files.push(ctx.file);
   return files;
 };