reslop 0.1.7 → 0.1.9

package/lib/diff/items.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const patch = require('./patch.js');
+const { splitHunk, formatHunkHeader, formatPatch } = patch;
+
+const INDEX_SIDE = {
+  staged: 'new',
+  unstaged: 'old',
+  untracked: 'old',
+  commit: 'old',
+  pr: 'old',
+};
+
+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 synthesizeNewFile = (relPath, content) => {
+  const { lines, noNl } = splitLines(content);
+  const body = lines.map((text, index) => ({
+    type: 'add',
+    text,
+    noNl: noNl && index === lines.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 preamble = [
+    `diff --git a/${relPath} b/${relPath}`,
+    'new file mode 100644',
+    '--- /dev/null',
+    `+++ b/${relPath}`,
+  ];
+  return {
+    oldPath: relPath,
+    newPath: relPath,
+    isNew: true,
+    isDeleted: false,
+    isBinary: false,
+    preamble,
+    hunks: [hunk],
+  };
+};
+
+const itemsFromFiles = (files, origin) => {
+  const items = [];
+  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 });
+      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);
+        const patchRevert = formatPatch(file, hunk, blockId, 'new');
+        items.push({ origin, file, hunk, blockId, patchAdd, patchRevert });
+      }
+    }
+  }
+  return items;
+};
+
+const refreshIndexPatches = (items, item) => {
+  if (!item.hunk || !item.file) return items;
+  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 next = [];
+  for (const other of items) {
+    if (other.hunk !== item.hunk || other.file !== item.file) {
+      next.push(other);
+      continue;
+    }
+    const patchAdd = formatPatch(other.file, other.hunk, other.blockId, sides);
+    next.push({ ...other, patchAdd });
+  }
+  return next;
+};
+
+module.exports = {
+  synthesizeNewFile,
+  itemsFromFiles,
+  refreshIndexPatches,
+};

package/lib/diff/parse.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const LINE_TYPE = {
+  '+': 'add',
+  '-': 'del',
+  ' ': 'ctx',
+};
+
+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;
+};
+
+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);
+  }
+  const tab = rest.indexOf('\t');
+  if (tab >= 0) rest = rest.slice(0, tab);
+  return stripAb(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 createFile = (line) => {
+  const paths = parseGitPaths(line);
+  return {
+    oldPath: paths.oldPath,
+    newPath: paths.newPath,
+    isNew: false,
+    isDeleted: false,
+    isBinary: false,
+    preamble: [line],
+    hunks: [],
+  };
+};
+
+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);
+  ctx.hunk = null;
+};
+
+const markNewFile = (line, ctx) => {
+  ctx.file.isNew = true;
+  ctx.file.preamble.push(line);
+};
+
+const markDeleted = (line, ctx) => {
+  ctx.file.isDeleted = true;
+  ctx.file.preamble.push(line);
+};
+
+const setOldPath = (line, ctx) => {
+  const parsed = parsePathLine(line);
+  if (parsed === '/dev/null') ctx.file.isNew = true;
+  else ctx.file.oldPath = parsed;
+  ctx.file.preamble.push(line);
+};
+
+const setNewPath = (line, ctx) => {
+  const parsed = parsePathLine(line);
+  if (parsed === '/dev/null') ctx.file.isDeleted = true;
+  else ctx.file.newPath = parsed;
+  ctx.file.preamble.push(line);
+};
+
+const startHunk = (line, ctx) => {
+  const meta = parseHunkHeader(line);
+  if (!meta) return;
+  ctx.hunk = { ...meta, lines: [] };
+  ctx.file.hunks.push(ctx.hunk);
+};
+
+const DIFF_PREFIX = [
+  { prefix: 'diff --git ', apply: startGitFile, needFile: false },
+  { prefix: 'Binary files ', apply: markBinary, needFile: true },
+  { prefix: 'GIT binary', apply: markBinary, needFile: true },
+  { prefix: 'new file mode', apply: markNewFile, needFile: true },
+  { prefix: 'deleted file mode', apply: markDeleted, needFile: true },
+  { prefix: '--- ', apply: setOldPath, needFile: true },
+  { prefix: '+++ ', apply: setNewPath, needFile: true },
+  { prefix: '@@ ', apply: startHunk, needFile: true },
+];
+
+const takeHunkLine = (line, hunk) => {
+  if (line.startsWith('\\')) {
+    const prev = hunk.lines[hunk.lines.length - 1];
+    if (prev) prev.noNl = true;
+    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 parseDiff = (text) => {
+  const files = [];
+  if (!text) return files;
+  const rawLines = text.split('\n');
+  if (rawLines.at(-1) === '') rawLines.pop();
+  const ctx = { files, file: null, hunk: null };
+  for (const raw of rawLines) {
+    const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+    const rule = DIFF_PREFIX.find((entry) => line.startsWith(entry.prefix));
+    if (rule) {
+      if (rule.needFile && !ctx.file) continue;
+      rule.apply(line, ctx);
+      continue;
+    }
+    if (!ctx.file) continue;
+    if (!ctx.hunk) {
+      ctx.file.preamble.push(line);
+      continue;
+    }
+    takeHunkLine(line, ctx.hunk);
+  }
+  closeFile(ctx.file, files);
+  return files;
+};
+
+module.exports = { parseDiff };

package/lib/diff/patch.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const { isCtxType } = require('./align.js');
+
+const LINE_MARK = {
+  add: '+',
+  del: '-',
+  ctx: ' ',
+  warn: ' ',
+  note: ' ',
+  noteSep: ' ',
+};
+
+const splitHunk = (hunk) => {
+  const { oldStart, oldCount, newStart, newCount, header } = hunk;
+  const blocks = [];
+  let current = null;
+  let blockId = -1;
+  const lines = hunk.lines.map((line) => {
+    if (isCtxType(line.type)) {
+      current = null;
+      return { ...line, blockId: null };
+    }
+    if (!current) {
+      blockId += 1;
+      current = { id: blockId };
+      blocks.push(current);
+    }
+    return { ...line, blockId };
+  });
+  const nextHunk = { oldStart, oldCount, newStart, newCount, header, lines };
+  return { hunk: nextHunk, blocks };
+};
+
+const otherContext = (contextSide, blockId) => {
+  if (contextSide === 'new') return 'new';
+  if (contextSide === 'old') return 'old';
+  return contextSide[blockId] ?? 'old';
+};
+
+const flattenBlock = (hunk, blockId, contextSide) => {
+  const out = [];
+  for (const line of hunk.lines) {
+    if (line.blockId === blockId || isCtxType(line.type)) {
+      out.push(line);
+      continue;
+    }
+    const side = otherContext(contextSide, line.blockId);
+    if (side === 'old' && line.type === 'del') {
+      out.push({ type: 'ctx', text: line.text, noNl: line.noNl });
+      continue;
+    }
+    if (side === 'new' && line.type === 'add') {
+      out.push({ type: 'ctx', text: line.text, noNl: line.noNl });
+    }
+  }
+  return out;
+};
+
+const countSides = (lines) => {
+  let oldCount = 0;
+  let newCount = 0;
+  for (const line of lines) {
+    if (isCtxType(line.type) || line.type === 'del') oldCount += 1;
+    if (isCtxType(line.type) || line.type === 'add') newCount += 1;
+  }
+  return { oldCount, newCount };
+};
+
+const formatHunkHeader = (oldStart, oldCount, newStart, newCount) =>
+  `@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`;
+
+const lineMark = (type) => LINE_MARK[type] ?? ' ';
+
+const formatBodyLine = (line) => {
+  const rows = [`${lineMark(line.type)}${line.text}`];
+  if (line.noNl) rows.push('\');
+  return rows;
+};
+
+const formatPatch = (file, hunk, blockId, contextSide) => {
+  const lines = flattenBlock(hunk, blockId, contextSide);
+  const counts = countSides(lines);
+  const header = formatHunkHeader(
+    hunk.oldStart,
+    counts.oldCount,
+    hunk.newStart,
+    counts.newCount,
+  );
+  const parts = [...file.preamble, header];
+  for (const line of lines) {
+    for (const row of formatBodyLine(line)) parts.push(row);
+  }
+  return `${parts.join('\n')}\n`;
+};
+
+module.exports = {
+  splitHunk,
+  flattenBlock,
+  countSides,
+  formatHunkHeader,
+  formatPatch,
+};