reslop 0.2.4 → 0.2.6

package/lib/session/change-actions.js

@@ -1,16 +1,17 @@
 'use strict';
 
+const fs = require('node:fs');
+const path = require('node:path');
+
 const files = require('../files.js');
-const { listPath, isTodoItem, isTodosEntry, isReadOnlyOrigin } = files;
+const { listPath, isTaskItem, isTasksEntry, isReadOnlyOrigin } = files;
 const items = require('./items.js');
 const { needsReload, npmBusyKind, sameBlock } = items;
 const diff = require('../diff/diff.js');
 const { hunkKey } = diff;
 
-const nextUnstageOrigin = (item) => {
-  if (item.file.isNew === true) return 'untracked';
-  return 'unstaged';
-};
+const nextUnstageOrigin = (item) =>
+  item.file.isNew === true ? 'untracked' : 'unstaged';
 
 const COMMANDS = {
   add: {
@@ -24,40 +25,64 @@ const COMMANDS = {
   revert: {
     match: () => true,
   },
+  ignore: {
+    match: () => true,
+  },
+};
+
+const IGNORE_FILES = ['.gitignore', '.npmignore'];
+
+const appendIgnoreFile = (top, name, pattern) => {
+  const abs = path.join(top, name);
+  const exists = fs.existsSync(abs);
+  if (name === '.npmignore' && !exists) return false;
+  const text = exists ? fs.readFileSync(abs, 'utf8') : '';
+  const lines = text.split('\n');
+  if (lines.some((line) => line.trim() === pattern)) return false;
+  const base = text && !text.endsWith('\n') ? `${text}\n` : text;
+  fs.writeFileSync(abs, `${base}${pattern}\n`);
+  return true;
+};
+
+const ignoreRelPath = (ui, rel) => {
+  const pattern = `${rel ?? ''}`.replace(/^\//, '');
+  if (!pattern) {
+    ui.status = 'not a diff block';
+    return;
+  }
+  const append = (name) => appendIgnoreFile(ui.top, name, pattern);
+  if (!IGNORE_FILES.map(append).includes(true)) {
+    ui.status = 'already ignored';
+    return;
+  }
+  ui.ignoreWatch();
+  ui.nav.clearSelection();
+  ui.reloadAfterChange();
+  ui.status = 'ignored';
 };
 
 const keepOrigin = (ui, item, origin) => {
   ui.collection.keepOrigin(item, origin);
   const idx = ui.collection.findRestoredIndex({ ...item, origin });
   if (idx >= 0) ui.nav.index = idx;
-  if (ui.ignoreWatch) ui.ignoreWatch();
+  ui.ignoreWatch();
   ui.nav.clearSelection();
   ui.syncReviewPath();
   ui.syncFileCursor();
 };
 
-const fileCursorEntry = (ui) => {
-  const list = ui.fileList();
-  return list[ui.nav.fileCursor] ?? null;
-};
-
 const fileActionItems = (ui) => {
-  const entry = fileCursorEntry(ui);
-  if (!entry || isTodosEntry(entry)) return [];
-  const rel = entry.path;
-  const selected = [];
-  for (const item of ui.items) {
-    if (isTodoItem(item)) continue;
-    if (listPath(item) !== rel) continue;
-    selected.push(item);
-  }
-  return selected;
+  const entry = ui.fileCursorEntry();
+  if (!entry || isTasksEntry(entry)) return [];
+  return ui.items.filter(
+    (item) => !isTaskItem(item) && listPath(item) === entry.path,
+  );
 };
 
 const activeDiffItem = (ui) => {
   const item = ui.current();
   if (!item) return null;
-  if (isTodoItem(item)) {
+  if (isTaskItem(item)) {
     ui.status = 'not a diff block';
     return null;
   }
@@ -91,16 +116,12 @@ const selectNextFileAfter = (ui, rel) => {
   nav.index = entry.firstIndex;
 };
 
-const liveItem = (ui, item) => {
-  for (const entry of ui.items) {
-    if (sameBlock(entry, item)) return entry;
-  }
-  return item;
-};
+const liveItem = (ui, item) =>
+  ui.items.find((entry) => sameBlock(entry, item)) ?? item;
 
-const applyGit = (ui, item, label, write, after) => {
+const applyGit = (ui, label, write, after) => {
   try {
-    write(ui.top, item);
+    write(ui.top);
     ui.status = label;
     after();
   } catch (error) {
@@ -108,78 +129,114 @@ const applyGit = (ui, item, label, write, after) => {
   }
 };
 
-const applyFileGit = (ui, targets, label, write, afterItem) => {
-  const { length } = targets;
-  const completed = new Array(length);
-  let n = 0;
+const applyFileGit = (ui, targets, label, write, afterItem = () => {}) => {
+  let written = 0;
   try {
-    for (let i = 0; i < length; i++) {
-      const current = liveItem(ui, targets[i]);
+    for (const target of targets) {
+      const current = liveItem(ui, target);
       write(ui.top, current);
       afterItem(current);
-      completed[n++] = current;
+      written++;
     }
-    completed.length = n;
     ui.status = label;
-    return { ok: true, completed };
+    return { ok: true, written };
   } catch (error) {
-    completed.length = n;
     ui.status = error.message;
-    return { ok: false, completed };
+    return { ok: false, written };
   }
 };
 
 const reconcilePartial = (ui, result) => {
   if (result.ok) return false;
-  if (result.completed.length) ui.reloadAfterChange();
+  if (result.written) ui.reloadAfterChange();
   return true;
 };
 
-const applyBlockAdd = (ui, item) => {
-  if (needsReload(item)) return void ui.reloadAfterChange();
-  keepOrigin(ui, item, 'staged');
+const enqueueOrigins = (ui, targets, spec) => {
+  const writes = targets.map((target) => {
+    const item = liveItem(ui, target);
+    keepOrigin(ui, item, spec.originOf(item));
+    return item;
+  });
+  if (spec.afterUi) spec.afterUi();
+  if (!spec.busy) ui.status = spec.done;
+  ui.ops.enqueueLazy({
+    kind: spec.busy || spec.done,
+    done: spec.done,
+    reload: spec.reload === true,
+    write: async (top) => {
+      for (const item of writes) await spec.write(top, item);
+    },
+  });
+};
+
+const stageLazy = (ui, targets, extra = {}) => {
+  const busy = extra.busy || '';
+  const repo = ui.repo;
+  enqueueOrigins(ui, targets, {
+    done: 'staged',
+    busy,
+    reload: extra.reload === true,
+    originOf: () => 'staged',
+    afterUi: extra.afterUi,
+    write: (top, item) => {
+      if (busy && repo.addAsync) return repo.addAsync(top, item);
+      return repo.add(top, item);
+    },
+  });
 };
 
-const onBlockAdd = (ui, item) => {
-  const busy = npmBusyKind(item);
+const unstageLazy = (ui, targets, extra = {}) => {
   const repo = ui.repo;
-  if (ui.uiOpen && busy && repo.addAsync) {
-    const after = () => applyBlockAdd(ui, item);
-    const write = (top) => repo.addAsync(top, item);
-    return void ui.ops.runBusy(busy, 'staged', write, after);
+  enqueueOrigins(ui, targets, {
+    done: 'unstaged',
+    busy: '',
+    originOf: nextUnstageOrigin,
+    afterUi: extra.afterUi,
+    write: (top, item) => repo.unstage(top, item),
+  });
+};
+
+const dismissReloadable = (ui, targets) => {
+  for (const item of targets) {
+    if (needsReload(item)) ui.collection.dismiss(item);
+  }
+};
+
+const onBlockAdd = (ui, item) => {
+  const reload = needsReload(item);
+  if (ui.uiOpen) {
+    return void stageLazy(ui, [item], { busy: npmBusyKind(item), reload });
   }
   applyGit(
     ui,
-    item,
     'staged',
-    (top, current) => repo.add(top, current),
+    (top) => ui.repo.add(top, item),
     () => {
-      applyBlockAdd(ui, item);
+      if (reload) ui.reloadAfterChange();
+      else keepOrigin(ui, item, 'staged');
     },
   );
 };
 
 const onBlockUnstage = (ui, item) => {
+  if (ui.uiOpen) return void unstageLazy(ui, [item]);
   const origin = nextUnstageOrigin(item);
-  const repo = ui.repo;
   applyGit(
     ui,
-    item,
     'unstaged',
-    (top, current) => repo.unstage(top, current),
+    (top) => ui.repo.unstage(top, item),
     () => keepOrigin(ui, item, origin),
   );
 };
 
 const onBlockRevert = (ui, item) => {
-  const repo = ui.repo;
   applyGit(
     ui,
-    item,
     'dropped',
-    (top, current) => repo.revert(top, current),
+    (top) => ui.repo.revert(top, item),
     () => {
-      if (needsReload(item)) ui.collection.dismiss(item);
+      dismissReloadable(ui, [item]);
       ui.reloadAfterChange();
     },
   );
@@ -195,6 +252,7 @@ const onBlockCommand = (ui, name) => {
   const command = COMMANDS[name];
   const item = activeDiffItem(ui);
   if (!guardWritable(ui, item)) return;
+  if (name === 'ignore') return void ignoreRelPath(ui, listPath(item));
   if (!command.match(item)) {
     ui.status = command.skipStatus;
     return;
@@ -202,176 +260,82 @@ const onBlockCommand = (ui, name) => {
   BLOCK[name](ui, item);
 };
 
-const writeFileAddAsync = (ui, targets) => async (top) => {
-  const repo = ui.repo;
-  for (const item of targets) {
-    const current = liveItem(ui, item);
-    await repo.addAsync(top, current);
-    keepOrigin(ui, current, 'staged');
-  }
-};
-
-const afterFileAdd = (ui, rel, proposed) => () => {
-  if (proposed) {
-    return void ui.reloadAfterChange(() => selectNextFileAfter(ui, rel));
-  }
-  selectNextFileAfter(ui, rel);
-};
-
-const onFileAdd = (ui) => {
-  const selected = fileActionItems(ui);
-  if (!selected.length) {
-    ui.status = 'not a diff block';
-    return;
-  }
-  if (!guardWritable(ui, selected[0])) return;
-  const rel = listPath(selected[0]);
-  const targets = selected.filter(COMMANDS.add.match);
-  if (!targets.length) {
-    ui.status = 'already staged';
-    selectNextFileAfter(ui, rel);
-    return;
+const stageTargets = (ui, targets, after = null) => {
+  const reload = targets.some(needsReload);
+  const busy = targets.map(npmBusyKind).find((kind) => kind) || '';
+  if (ui.uiOpen) {
+    return void stageLazy(ui, targets, { busy, reload, afterUi: after });
   }
-  const proposed = targets.some(needsReload);
-  const busy = targets.map(npmBusyKind).find((kind) => kind);
-  const repo = ui.repo;
-  if (ui.uiOpen && busy && repo.addAsync) {
-    const write = writeFileAddAsync(ui, targets);
-    const after = afterFileAdd(ui, rel, proposed);
-    return void ui.ops.runBusy(busy, 'staged', write, after);
-  }
-  const result = applyFileGit(
-    ui,
-    targets,
-    'staged',
-    (top, current) => repo.add(top, current),
-    (item) => keepOrigin(ui, item, 'staged'),
-  );
+  const keepStaged = (entry) => keepOrigin(ui, entry, 'staged');
+  const result = applyFileGit(ui, targets, 'staged', ui.repo.add, keepStaged);
   if (reconcilePartial(ui, result)) return;
-  if (proposed) ui.reloadAfterChange();
-  selectNextFileAfter(ui, rel);
+  if (reload) ui.reloadAfterChange();
+  if (after) after();
 };
 
-const onFileUnstage = (ui) => {
-  const selected = fileActionItems(ui);
-  if (!selected.length) {
-    ui.status = 'not a diff block';
-    return;
-  }
-  if (!guardWritable(ui, selected[0])) return;
-  const rel = listPath(selected[0]);
-  const targets = selected.filter(COMMANDS.unstage.match);
-  if (!targets.length) {
-    ui.status = 'not staged';
-    selectNextFileAfter(ui, rel);
-    return;
-  }
-  const repo = ui.repo;
+const unstageTargets = (ui, targets, after = null) => {
+  if (ui.uiOpen) return void unstageLazy(ui, targets, { afterUi: after });
+  const keepUnstaged = (entry) =>
+    keepOrigin(ui, entry, nextUnstageOrigin(entry));
   const result = applyFileGit(
     ui,
     targets,
     'unstaged',
-    (top, current) => repo.unstage(top, current),
-    (item) => keepOrigin(ui, item, nextUnstageOrigin(item)),
+    ui.repo.unstage,
+    keepUnstaged,
   );
   if (reconcilePartial(ui, result)) return;
-  selectNextFileAfter(ui, rel);
+  if (after) after();
 };
 
-const onFileRevert = (ui) => {
-  const selected = fileActionItems(ui);
-  if (!selected.length) {
-    ui.status = 'not a diff block';
-    return;
-  }
-  if (!guardWritable(ui, selected[0])) return;
-  const rel = listPath(selected[0]);
-  for (const item of selected) {
-    if (needsReload(item)) ui.collection.dismiss(item);
-  }
-  let ok = false;
+const revertTargets = (ui, targets) => {
+  dismissReloadable(ui, targets);
+  const result = applyFileGit(ui, targets, 'dropped', ui.repo.revert);
+  if (!result.ok && !result.written) return;
+  ui.reloadAfterChange();
+};
+
+const revertFile = (ui, rel, selected, after) => {
+  dismissReloadable(ui, selected);
   try {
     ui.repo.revertFile(ui.top, rel, selected);
     ui.status = 'dropped';
-    ok = true;
   } catch (error) {
     ui.status = error.message;
+    return void ui.reloadAfterChange();
   }
-  const after = ok ? () => selectNextFileAfter(ui, rel) : null;
   ui.reloadAfterChange(after);
 };
 
-const FILE = {
-  add: onFileAdd,
-  unstage: onFileUnstage,
-  revert: onFileRevert,
-};
-
-const hunkActionItems = (ui, item) => {
-  const key = hunkKey(item);
-  const selected = [];
-  if (!key) return selected;
-  for (const entry of ui.items) {
-    if (hunkKey(entry) !== key) continue;
-    selected.push(entry);
-  }
-  return selected;
+const TARGETS = {
+  add: stageTargets,
+  unstage: unstageTargets,
+  revert: revertTargets,
 };
 
-const onUnitAdd = (ui, targets) => {
-  const proposed = targets.some(needsReload);
-  const busy = targets.map(npmBusyKind).find((kind) => kind);
-  const repo = ui.repo;
-  if (ui.uiOpen && busy && repo.addAsync) {
-    const write = writeFileAddAsync(ui, targets);
-    const after = () => {
-      if (proposed) ui.reloadAfterChange();
-    };
-    return void ui.ops.runBusy(busy, 'staged', write, after);
+const onFileCommand = (ui, name) => {
+  const selected = fileActionItems(ui);
+  if (!selected.length) {
+    ui.status = 'not a diff block';
+    return;
   }
-  const result = applyFileGit(
-    ui,
-    targets,
-    'staged',
-    (top, current) => repo.add(top, current),
-    (entry) => keepOrigin(ui, entry, 'staged'),
-  );
-  if (reconcilePartial(ui, result)) return;
-  if (proposed) ui.reloadAfterChange();
-};
-
-const onUnitUnstage = (ui, targets) => {
-  const repo = ui.repo;
-  const result = applyFileGit(
-    ui,
-    targets,
-    'unstaged',
-    (top, current) => repo.unstage(top, current),
-    (entry) => keepOrigin(ui, entry, nextUnstageOrigin(entry)),
-  );
-  reconcilePartial(ui, result);
-};
-
-const onUnitRevert = (ui, targets) => {
-  for (const item of targets) {
-    if (needsReload(item)) ui.collection.dismiss(item);
+  if (!guardWritable(ui, selected[0])) return;
+  const rel = listPath(selected[0]);
+  const next = () => selectNextFileAfter(ui, rel);
+  if (name === 'ignore') return void ignoreRelPath(ui, rel);
+  if (name === 'revert') return void revertFile(ui, rel, selected, next);
+  const command = COMMANDS[name];
+  const targets = selected.filter(command.match);
+  if (!targets.length) {
+    ui.status = command.skipStatus;
+    return void next();
   }
-  const repo = ui.repo;
-  const result = applyFileGit(
-    ui,
-    targets,
-    'dropped',
-    (top, current) => repo.revert(top, current),
-    (entry) => entry,
-  );
-  if (!result.ok && !result.completed.length) return;
-  ui.reloadAfterChange();
+  TARGETS[name](ui, targets, next);
 };
 
-const UNIT = {
-  add: onUnitAdd,
-  unstage: onUnitUnstage,
-  revert: onUnitRevert,
+const hunkActionItems = (ui, item) => {
+  const key = hunkKey(item);
+  return key ? ui.items.filter((entry) => hunkKey(entry) === key) : [];
 };
 
 const onUnitCommand = (ui, name) => {
@@ -384,20 +348,13 @@ const onUnitCommand = (ui, name) => {
     ui.status = command.skipStatus ?? 'not a diff block';
     return;
   }
-  UNIT[name](ui, targets);
+  TARGETS[name](ui, targets);
 };
 
 const onCommand = (ui, name) => {
-  if (ui.nav.pane === 'files') return void FILE[name](ui);
+  if (ui.nav.pane === 'files') return void onFileCommand(ui, name);
   if (ui.nav.pane === 'unit') return void onUnitCommand(ui, name);
   onBlockCommand(ui, name);
 };
 
-const createChangeActions = (ui) => ({
-  fileCursorEntry: () => fileCursorEntry(ui),
-  onAdd: () => onCommand(ui, 'add'),
-  onUnstage: () => onCommand(ui, 'unstage'),
-  onRevert: () => onCommand(ui, 'revert'),
-});
-
-module.exports = { createChangeActions };
+module.exports = { onCommand };