reslop 0.2.5 → 0.2.7

package/lib/diff/align.js

@@ -18,9 +18,7 @@ const lineTokens = (text) => {
 
 const pairScore = (a, b) => {
   const token = tokenSimilarity(a, b);
-  const headA = a[0];
-  const headB = b[0];
-  const head = headA && headA === headB ? 1 : 0;
+  const head = a[0] && a[0] === b[0] ? 1 : 0;
   return PAIR_HEAD_WEIGHT * head + PAIR_TOKEN_WEIGHT * token;
 };
 
@@ -44,15 +42,13 @@ const pairCandidates = (delTexts, addTexts) => {
       candidates.push({ i, j, score, dist });
     }
   }
-  candidates.sort(comparePair);
-  return candidates;
+  return candidates.sort(comparePair);
 };
 
 const pairIndices = (delTexts, addTexts) => {
   const delToAdd = new Array(delTexts.length).fill(-1);
   const addUsed = new Array(addTexts.length).fill(false);
-  const candidates = pairCandidates(delTexts, addTexts);
-  for (const pair of candidates) {
+  for (const pair of pairCandidates(delTexts, addTexts)) {
     if (delToAdd[pair.i] >= 0 || addUsed[pair.j]) continue;
     delToAdd[pair.i] = pair.j;
     addUsed[pair.j] = true;
@@ -66,155 +62,87 @@ const pairIndices = (delTexts, addTexts) => {
   return delToAdd;
 };
 
-const changeSides = (block) => {
-  const dels = [];
-  const adds = [];
-  for (const line of block) {
-    if (line.type === 'del') dels.push(line);
-    if (line.type === 'add') adds.push(line);
-  }
-  return { dels, adds };
+const pairBlock = (block) => {
+  const dels = block.filter((line) => line.type === 'del');
+  const adds = block.filter((line) => line.type === 'add');
+  const delToAdd = pairIndices(
+    dels.map((line) => line.text),
+    adds.map((line) => line.text),
+  );
+  return { dels, adds, delToAdd };
 };
 
-const applyInlineSpans = (dels, adds, delToAdd) => {
-  const addSeen = new Set();
+const wholeSpans = (text, changed) => [{ text, changed }];
+
+const attachInline = (lines) => {
+  const painted = lines.map((line) => ({ ...line }));
+  const { dels, adds, delToAdd } = pairBlock(painted);
+  for (const add of adds) add.spans = wholeSpans(add.text, true);
   for (let i = 0; i < dels.length; i++) {
     const j = delToAdd[i];
     if (j < 0) {
-      dels[i].spans = [{ text: dels[i].text, changed: true }];
+      dels[i].spans = wholeSpans(dels[i].text, true);
       continue;
     }
-    addSeen.add(j);
     const diff = diffChars(dels[i].text, adds[j].text);
     dels[i].spans = diff.oldSpans;
     adds[j].spans = diff.newSpans;
   }
-  for (let j = 0; j < adds.length; j++) {
-    if (addSeen.has(j)) continue;
-    adds[j].spans = [{ text: adds[j].text, changed: true }];
-  }
-};
-
-const attachInline = (lines) => {
-  const painted = lines.map((line) => ({ ...line }));
-  const { dels, adds } = changeSides(painted);
-  const delToAdd = pairIndices(
-    dels.map((line) => line.text),
-    adds.map((line) => line.text),
-  );
-  applyInlineSpans(dels, adds, delToAdd);
   for (const line of painted) {
-    if (isCtxType(line.type)) {
-      line.spans = [{ text: line.text, changed: false }];
-    }
+    if (isCtxType(line.type)) line.spans = wholeSpans(line.text, false);
   }
   return painted;
 };
 
-const addPartners = (delToAdd, addCount) => {
-  const addToDel = new Array(addCount).fill(-1);
-  for (let i = 0; i < delToAdd.length; i++) {
-    const j = delToAdd[i];
-    if (j >= 0) addToDel[j] = i;
-  }
-  return addToDel;
-};
-
-const walkAligned = (dels, adds, delToAdd, emit) => {
-  const addToDel = addPartners(delToAdd, adds.length);
-  const usedAdd = new Array(adds.length).fill(false);
+const pushAligned = (rows, dels, adds, delToAdd) => {
+  const paired = new Array(adds.length).fill(false);
+  for (const j of delToAdd) if (j >= 0) paired[j] = true;
   let addPos = 0;
-  const takeUnpairedAdds = (limit) => {
-    while (addPos < limit) {
-      const free = addToDel[addPos] < 0 && !usedAdd[addPos];
-      if (free) {
-        emit.unpairedAdd(adds[addPos]);
-        usedAdd[addPos] = true;
-      }
-      addPos += 1;
+  const takeAdds = (limit) => {
+    for (; addPos < limit; addPos++) {
+      if (!paired[addPos]) rows.push({ left: null, right: adds[addPos] });
     }
   };
   for (let i = 0; i < dels.length; i++) {
     const j = delToAdd[i];
     if (j < 0) {
-      emit.unpairedDel(dels[i]);
+      rows.push({ left: dels[i], right: null });
       continue;
     }
-    takeUnpairedAdds(j);
-    emit.pair(dels[i], adds[j]);
-    usedAdd[j] = true;
+    takeAdds(j);
+    rows.push({ left: dels[i], right: adds[j] });
     if (addPos <= j) addPos = j + 1;
   }
-  takeUnpairedAdds(adds.length);
-  for (let j = 0; j < adds.length; j++) {
-    if (!usedAdd[j]) emit.unpairedAdd(adds[j]);
-  }
+  takeAdds(adds.length);
 };
 
-const alignChangeBlock = (dels, adds, delToAdd) => {
-  const out = [];
-  walkAligned(dels, adds, delToAdd, {
-    unpairedDel: (del) => {
-      out.push(del);
-    },
-    unpairedAdd: (add) => {
-      out.push(add);
-    },
-    pair: (del, add) => {
-      out.push(del);
-      out.push(add);
-    },
-  });
-  return out;
-};
-
-const mapHunkBlocks = (lines, onCtx, onChange) => {
-  const out = [];
+const sideRows = (lines) => {
+  const rows = [];
   let i = 0;
   while (i < lines.length) {
     if (isCtxType(lines[i].type)) {
-      out.push(onCtx(lines[i]));
+      rows.push({ left: lines[i], right: lines[i] });
       i += 1;
       continue;
     }
     const start = i;
     while (i < lines.length && !isCtxType(lines[i].type)) i += 1;
-    const block = lines.slice(start, i);
-    const { dels, adds } = changeSides(block);
-    const delToAdd = pairIndices(
-      dels.map((line) => line.text),
-      adds.map((line) => line.text),
-    );
-    for (const row of onChange(dels, adds, delToAdd)) out.push(row);
+    const { dels, adds, delToAdd } = pairBlock(lines.slice(start, i));
+    pushAligned(rows, dels, adds, delToAdd);
   }
-  return out;
+  return rows;
 };
 
-const alignSplitBlock = (dels, adds, delToAdd) => {
+const mixedLines = (lines) => {
   const out = [];
-  walkAligned(dels, adds, delToAdd, {
-    unpairedDel: (del) => {
-      out.push({ left: del, right: null });
-    },
-    unpairedAdd: (add) => {
-      out.push({ left: null, right: add });
-    },
-    pair: (del, add) => {
-      out.push({ left: del, right: add });
-    },
-  });
+  for (const { left, right } of sideRows(lines)) {
+    if (left) out.push(left);
+    if (right && right !== left) out.push(right);
+  }
   return out;
 };
 
-const LAYOUT_ALIGN = {
-  mixed: (lines) => mapHunkBlocks(lines, (line) => line, alignChangeBlock),
-  side: (lines) =>
-    mapHunkBlocks(
-      lines,
-      (line) => ({ left: line, right: line }),
-      alignSplitBlock,
-    ),
-};
+const LAYOUT_ALIGN = { mixed: mixedLines, side: sideRows };
 
 module.exports = {
   isCtxType,

package/lib/diff/diff.js

@@ -1,56 +1,25 @@
 'use strict';
 
 const inline = require('./inline.js');
-const { diffChars } = inline;
 const align = require('./align.js');
-const { isCtxType, pairIndices, attachInline } = align;
 const parse = require('./parse.js');
-const { parseDiff } = parse;
 const patch = require('./patch.js');
-const { splitHunk, flattenBlock, countSides, formatPatch } = patch;
 const display = require('./display.js');
-const { DISPLAY_CONTEXT, displayLines, blockAddText } = display;
 const edit = require('./edit.js');
-const { addBlockRange, replaceBlockAdds } = edit;
 const items = require('./items.js');
-const { synthesizeNewFile, itemsFromFiles, refreshIndexPatches } = items;
 const unit = require('./unit.js');
-const { unitLines, itemsForPath, blockLineRange, blockLineIndex } = unit;
-const { hunkLineRange, hunkKey, sameHunk, splitEditor } = unit;
-const { fileOffset, fileLines, sameBlock, splitFile } = unit;
-const { fileLineIndex, attachEditSpans, mergeEditRows } = unit;
 
 module.exports = {
-  DISPLAY_CONTEXT,
-  isCtxType,
-  diffChars,
-  pairIndices,
-  attachInline,
-  parseDiff,
-  splitHunk,
-  flattenBlock,
-  countSides,
-  formatPatch,
-  displayLines,
-  blockAddText,
-  addBlockRange,
-  replaceBlockAdds,
-  synthesizeNewFile,
-  itemsFromFiles,
-  refreshIndexPatches,
-  splitFile,
-  splitEditor,
-  itemsForPath,
-  unitLines,
-  sameBlock,
-  sameHunk,
-  hunkKey,
-  blockLineRange,
-  hunkLineRange,
-  blockLineIndex,
-  fileOffset,
-  fileLines,
-  fileLineIndex,
-  attachEditSpans,
-  mergeEditRows,
+  diffChars: inline.diffChars,
+  isCtxType: align.isCtxType,
+  pairIndices: align.pairIndices,
+  attachInline: align.attachInline,
+  parseDiff: parse.parseDiff,
+  splitHunk: patch.splitHunk,
+  flattenBlock: patch.flattenBlock,
+  formatPatch: patch.formatPatch,
+  ...display,
+  ...edit,
+  ...items,
+  ...unit,
 };

package/lib/diff/display.js

@@ -23,41 +23,35 @@ const windowAroundBlock = (lines, blockId, radius) => {
 
 const insertAddIndex = (lines) => {
   for (let i = lines.length - 1; i >= 0; i--) {
-    if (isCtxType(lines[i].type)) continue;
-    return i + 1;
+    if (!isCtxType(lines[i].type)) return i + 1;
   }
   return lines.length;
 };
 
-const taggedAdd = (text, blockId, start, end) => ({
-  type: 'add',
-  text,
-  noNl: false,
-  blockId,
-  wrap: true,
-  editStart: start,
-  editEnd: end,
-  editLast: true,
-});
+const taggedAdds = (text, blockId) => {
+  const tagged = [];
+  let offset = 0;
+  for (const row of text.split('\n')) {
+    tagged.push({
+      type: 'add',
+      text: row,
+      noNl: false,
+      blockId,
+      wrap: true,
+      editStart: offset,
+      editEnd: offset + row.length,
+      editLast: true,
+    });
+    offset += row.length + 1;
+  }
+  return tagged;
+};
 
 const replaceAdds = (lines, overlay, blockId) => {
-  const text = overlay.text ?? '';
-  const keepEmpty = overlay.keepEmpty === true;
-  if (text === '' && !keepEmpty) {
+  if (overlay.text === '' && !overlay.keepEmpty) {
     return lines.filter((line) => line.type !== 'add');
   }
-  const texts = text.split('\n');
-  const { length } = texts;
-  const tagged = new Array(length);
-  let offset = 0;
-  for (let i = 0; i < length; i++) {
-    const row = texts[i];
-    const start = offset;
-    const end = start + row.length;
-    const isLast = i === length - 1;
-    tagged[i] = taggedAdd(row, blockId, start, end);
-    offset = isLast ? end : end + 1;
-  }
+  const tagged = taggedAdds(overlay.text, blockId);
   const out = [];
   let placed = 0;
   let lastAdd = -1;
@@ -67,9 +61,8 @@ const replaceAdds = (lines, overlay, blockId) => {
       continue;
     }
     if (placed >= tagged.length) continue;
-    out.push(tagged[placed]);
+    out.push(tagged[placed++]);
     lastAdd = out.length - 1;
-    placed += 1;
   }
   const extras = tagged.slice(placed);
   if (!extras.length) return out;
@@ -82,9 +75,7 @@ const blockAddText = (hunk, blockId) => {
   if (!hunk) return '';
   const parts = [];
   for (const line of hunk.lines) {
-    if (line.type !== 'add') continue;
-    if (line.blockId !== blockId) continue;
-    parts.push(line.text);
+    if (line.type === 'add' && line.blockId === blockId) parts.push(line.text);
   }
   return parts.join('\n');
 };
@@ -93,11 +84,9 @@ const displayLines = (hunk, blockId, layout = 'unified', radius, overlay) => {
   const flat = flattenBlock(hunk, blockId, 'new');
   const source = overlay ? replaceAdds(flat, overlay, blockId) : flat;
   const around = radius ?? DISPLAY_CONTEXT;
-  const windowed = windowAroundBlock(source, blockId, around);
-  const painted = attachInline(windowed);
+  const painted = attachInline(windowAroundBlock(source, blockId, around));
   const alignRows = LAYOUT_ALIGN[layout];
-  if (alignRows) return alignRows(painted);
-  return painted;
+  return alignRows ? alignRows(painted) : painted;
 };
 
 module.exports = { DISPLAY_CONTEXT, displayLines, blockAddText };

package/lib/diff/edit.js

@@ -1,19 +1,5 @@
 'use strict';
 
-const contentLines = (content) => {
-  if (content === '') return { lines: [], ended: false };
-  const ended = content.endsWith('\n');
-  const body = ended ? content.slice(0, -1) : content;
-  return { lines: body.split('\n'), ended };
-};
-
-const joinLines = (lines, ended) => {
-  const body = lines.join('\n');
-  if (!ended) return body;
-  if (!lines.length) return '\n';
-  return `${body}\n`;
-};
-
 const addBlockRange = (hunk, blockId) => {
   let newLine = hunk.newStart;
   let start = 0;
@@ -35,13 +21,13 @@ const addBlockRange = (hunk, blockId) => {
 
 const replaceBlockAdds = (content, hunk, blockId, text) => {
   const range = addBlockRange(hunk, blockId);
-  const parsed = contentLines(content);
-  const last = parsed.lines.length;
-  const from = Math.min(last, Math.max(0, range.start - 1));
+  const ended = content.endsWith('\n');
+  const body = ended ? content.slice(0, -1) : content;
+  const lines = content === '' ? [] : body.split('\n');
+  const from = Math.min(lines.length, Math.max(0, range.start - 1));
   const added = text === '' ? [] : text.split('\n');
-  const next = parsed.lines.slice();
-  next.splice(from, range.count, ...added);
-  return joinLines(next, parsed.ended);
+  lines.splice(from, range.count, ...added);
+  return lines.join('\n') + (ended ? '\n' : '');
 };
 
 module.exports = { addBlockRange, replaceBlockAdds };