reslop 0.2.3 → 0.2.5

package/lib/session/change-actions.js

@@ -1,10 +1,14 @@
 '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 { hunkKey } = require('../diff/diff.js');
+const diff = require('../diff/diff.js');
+const { hunkKey } = diff;
 
 const nextUnstageOrigin = (item) => {
   if (item.file.isNew === true) return 'untracked';
@@ -23,13 +27,63 @@ const COMMANDS = {
   revert: {
     match: () => true,
   },
+  ignore: {
+    match: () => true,
+  },
+};
+
+const IGNORE_FILES = ['.gitignore', '.npmignore'];
+
+const ignorePatternListed = (text, pattern) => {
+  for (const line of `${text ?? ''}`.split('\n')) {
+    if (line.trim() === pattern) return true;
+  }
+  return false;
+};
+
+const appendIgnorePattern = (text, pattern) => {
+  if (ignorePatternListed(text, pattern)) return text;
+  const base = text.length && !text.endsWith('\n') ? `${text}\n` : text;
+  return `${base}${pattern}\n`;
+};
+
+const appendIgnoreFile = (top, name, pattern) => {
+  const abs = path.join(top, name);
+  if (name === '.npmignore' && !fs.existsSync(abs)) return false;
+  const text = fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : '';
+  const next = appendIgnorePattern(text, pattern);
+  if (next === text) return false;
+  fs.writeFileSync(abs, next);
+  return true;
+};
+
+const ignoreRelPath = (ui, rel) => {
+  const pattern = `${rel ?? ''}`.replace(/^\//, '');
+  if (!pattern) {
+    ui.status = 'not a diff block';
+    return;
+  }
+  let changed = false;
+  for (const name of IGNORE_FILES) {
+    if (appendIgnoreFile(ui.top, name, pattern)) changed = true;
+  }
+  if (!changed) {
+    ui.status = 'already ignored';
+    return;
+  }
+  ui.ignoreWatch();
+  ui.nav.clearSelection();
+  ui.reloadAfterChange();
+  ui.status = 'ignored';
 };
 
+const sameEntry = (entry) => entry;
+
 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();
@@ -42,11 +96,11 @@ const fileCursorEntry = (ui) => {
 
 const fileActionItems = (ui) => {
   const entry = fileCursorEntry(ui);
-  if (!entry || isTodosEntry(entry)) return [];
+  if (!entry || isTasksEntry(entry)) return [];
   const rel = entry.path;
   const selected = [];
   for (const item of ui.items) {
-    if (isTodoItem(item)) continue;
+    if (isTaskItem(item)) continue;
     if (listPath(item) !== rel) continue;
     selected.push(item);
   }
@@ -56,7 +110,7 @@ const fileActionItems = (ui) => {
 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;
   }
@@ -139,13 +193,60 @@ const applyBlockAdd = (ui, item) => {
   keepOrigin(ui, item, 'staged');
 };
 
+const enqueueOrigins = (ui, targets, spec) => {
+  const writes = new Array(targets.length);
+  for (let i = 0; i < targets.length; i++) {
+    const current = liveItem(ui, targets[i]);
+    writes[i] = current;
+    keepOrigin(ui, current, spec.originOf(current));
+  }
+  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 unstageLazy = (ui, targets, extra = {}) => {
+  const repo = ui.repo;
+  enqueueOrigins(ui, targets, {
+    done: 'unstaged',
+    busy: '',
+    originOf: nextUnstageOrigin,
+    afterUi: extra.afterUi,
+    write: (top, item) => repo.unstage(top, item),
+  });
+};
+
 const onBlockAdd = (ui, item) => {
   const busy = npmBusyKind(item);
   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);
+  if (ui.uiOpen) {
+    return void stageLazy(ui, [item], {
+      busy,
+      reload: needsReload(item),
+    });
   }
   applyGit(
     ui,
@@ -159,6 +260,7 @@ const onBlockAdd = (ui, item) => {
 };
 
 const onBlockUnstage = (ui, item) => {
+  if (ui.uiOpen) return void unstageLazy(ui, [item]);
   const origin = nextUnstageOrigin(item);
   const repo = ui.repo;
   applyGit(
@@ -170,6 +272,12 @@ const onBlockUnstage = (ui, item) => {
   );
 };
 
+const dismissReloadable = (ui, targets) => {
+  for (const item of targets) {
+    if (needsReload(item)) ui.collection.dismiss(item);
+  }
+};
+
 const onBlockRevert = (ui, item) => {
   const repo = ui.repo;
   applyGit(
@@ -178,7 +286,7 @@ const onBlockRevert = (ui, item) => {
     'dropped',
     (top, current) => repo.revert(top, current),
     () => {
-      if (needsReload(item)) ui.collection.dismiss(item);
+      dismissReloadable(ui, [item]);
       ui.reloadAfterChange();
     },
   );
@@ -194,6 +302,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;
@@ -201,109 +310,83 @@ 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 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 keepStaged = (entry) => keepOrigin(ui, entry, 'staged');
+  const result = applyFileGit(ui, targets, 'staged', ui.repo.add, keepStaged);
+  if (reconcilePartial(ui, result)) return;
+  if (reload) ui.reloadAfterChange();
+  if (after) after();
 };
 
-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 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 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,
-    'staged',
-    (top, current) => repo.add(top, current),
-    (item) => keepOrigin(ui, item, 'staged'),
+    'unstaged',
+    ui.repo.unstage,
+    keepUnstaged,
   );
   if (reconcilePartial(ui, result)) return;
-  if (proposed) ui.reloadAfterChange();
-  selectNextFileAfter(ui, rel);
+  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 revertTargets = (ui, targets) => {
+  dismissReloadable(ui, targets);
   const result = applyFileGit(
     ui,
     targets,
-    'unstaged',
-    (top, current) => repo.unstage(top, current),
-    (item) => keepOrigin(ui, item, nextUnstageOrigin(item)),
+    'dropped',
+    ui.repo.revert,
+    sameEntry,
   );
-  if (reconcilePartial(ui, result)) return;
-  selectNextFileAfter(ui, rel);
+  if (!result.ok && !result.completed.length) return;
+  ui.reloadAfterChange();
 };
 
-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 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 TARGETS = {
+  add: stageTargets,
+  unstage: unstageTargets,
+  revert: revertTargets,
+};
+
+const onFileCommand = (ui, name) => {
+  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 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();
+  }
+  TARGETS[name](ui, targets, next);
 };
 
 const hunkActionItems = (ui, item) => {
@@ -317,62 +400,6 @@ const hunkActionItems = (ui, item) => {
   return selected;
 };
 
-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 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);
-  }
-  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();
-};
-
-const UNIT = {
-  add: onUnitAdd,
-  unstage: onUnitUnstage,
-  revert: onUnitRevert,
-};
-
 const onUnitCommand = (ui, name) => {
   const command = COMMANDS[name];
   const item = activeDiffItem(ui);
@@ -383,11 +410,11 @@ 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);
 };
@@ -397,6 +424,7 @@ const createChangeActions = (ui) => ({
   onAdd: () => onCommand(ui, 'add'),
   onUnstage: () => onCommand(ui, 'unstage'),
   onRevert: () => onCommand(ui, 'revert'),
+  onIgnore: () => onCommand(ui, 'ignore'),
 });
 
 module.exports = { createChangeActions };

package/lib/session/commit.js

@@ -1,15 +1,16 @@
 'use strict';
 
-const { stateView } = require('./accessors.js');
-
-const { isReadOnlyOrigin } = require('../files.js');
-const { isFixupCommit } = require('./actions.js');
-const { pickRepoWrite } = require('./ops.js');
-const {
-  commitLine,
-  commitText,
-  splitMessage,
-} = require('../render/commits.js');
+const accessors = require('./accessors.js');
+const { stateView } = accessors;
+
+const files = require('../files.js');
+const { isReadOnlyOrigin } = files;
+const actions = require('./actions.js');
+const { isFixupCommit } = actions;
+const ops = require('./ops.js');
+const { pickRepoWrite } = ops;
+const commits = require('../render/commits.js');
+const { commitLine, commitText, splitMessage } = commits;
 
 const COMMIT_STATUS = {
   commit: 'committed',
@@ -42,6 +43,13 @@ const briefCommit = (ui) => ui.commits.commitView !== 'full';
 
 const joinMessage = (line, rest) => (rest ? `${line}\n${rest}` : line);
 
+const tidyCommitMessage = (message) => {
+  const lines = `${message ?? ''}`.split('\n').map((line) => line.trim());
+  while (lines.length && lines[0] === '') lines.shift();
+  while (lines.length && lines[lines.length - 1] === '') lines.pop();
+  return lines.join('\n');
+};
+
 const keepBriefBody = (ui, text) => {
   if (!briefCommit(ui)) return text;
   const parts = splitMessage(text);
@@ -90,6 +98,24 @@ const clampCommitCursor = (api) => {
   if (nav.commitCursor > last) nav.commitCursor = Math.max(0, last);
 };
 
+const commitIndexForView = (api) => {
+  const ui = api.ui;
+  if (hasStagedChanges(ui)) return 0;
+  const list = listedCommits(api.state.commits);
+  const want = `${ui.rev ?? ''}`;
+  const short = `${ui.revShort ?? ''}`;
+  if (!want && !short) return 0;
+  for (let i = 0; i < list.length; i++) {
+    const entry = list[i];
+    if (!entry || entry.pending) continue;
+    const sha = `${entry.sha ?? ''}`;
+    const brief = `${entry.shortSha ?? ''}`;
+    if (want && sha === want) return i;
+    if (short && (brief === short || sha.startsWith(short))) return i;
+  }
+  return 0;
+};
+
 const refreshCommitList = (api) => {
   const repo = api.ui.repo;
   if (!repo.listCommits) return;
@@ -120,10 +146,12 @@ const showCommits = (api) => {
     api.ui.status = error.message;
     return;
   }
-  api.ui.nav.commitCursor = 0;
-  api.ui.nav.pane = 'commits';
+  const nav = api.ui.nav;
+  nav.commitCursor = commitIndexForView(api);
+  nav.pane = 'commits';
+  nav.resetListScroll('commits');
   api.ui.status = '';
-  api.ui.nav.clearSelection();
+  nav.clearSelection();
 };
 
 const onCommitMove = (api, delta) => {
@@ -181,11 +209,23 @@ const onCommit = (api) => {
   startGitCommit(api, 'commit');
 };
 
+const openLoadedDiff = (ui) => {
+  ui.nav.tasksOpen = false;
+  ui.nav.scroll = 0;
+  ui.nav.index = 0;
+  ui.nav.pane = ui.items.length ? 'diff' : 'files';
+  ui.syncReviewPath();
+  ui.syncFileCursor();
+  ui.status = '';
+};
+
 const showSelectedDiff = (api) => {
   if (api.ui.mode === 'compose') return;
   const entry = selectedCommit(api);
   if (!entry) return;
   const ui = api.ui;
+  const viewingCommit = Boolean(ui.rev || ui.revShort);
+  if (isPending(entry) && !viewingCommit) return void onCommit(api);
   if (isPending(entry) || !entry.sha) {
     ui.rev = '';
     ui.revShort = '';
@@ -193,16 +233,10 @@ const showSelectedDiff = (api) => {
     ui.rev = entry.sha;
     ui.revShort = entry.shortSha || '';
   }
-  const openDiff = () => {
-    ui.nav.todoOpen = false;
-    ui.nav.scroll = 0;
-    ui.nav.index = 0;
-    ui.nav.pane = ui.items.length ? 'diff' : 'files';
-    ui.syncReviewPath();
-    ui.syncFileCursor();
-    ui.status = '';
-  };
-  ui.refreshFromRepo({ keepEmpty: true, afterLoad: openDiff });
+  ui.refreshFromRepo({
+    keepEmpty: true,
+    afterLoad: () => openLoadedDiff(ui),
+  });
 };
 
 const onAmend = (api) => {
@@ -226,18 +260,9 @@ const applyFixupNow = (api) => {
     api.ui.status = 'read only';
     return;
   }
-  const picked = pickRepoWrite(repo, 'applyFixup', api.ui.uiOpen);
-  if (picked.async) {
-    const run = (top) => picked.write(top, entry.sha);
-    const after = () => refreshAfterWrite(api, { doneStatus: done });
-    return void api.ui.ops.runBusy('applying', done, run, after);
-  }
-  const ok = api.ui.ops.runRepo(done, (top) => {
-    repo.applyFixup(top, entry.sha);
-  });
-  if (!ok) return;
-  refreshAfterWrite(api);
-  if (!api.ui.status) api.ui.status = done;
+  api.ui.ops.runWrite('applyFixup', [entry.sha], 'applying', done, (extra) =>
+    refreshAfterWrite(api, extra),
+  );
 };
 
 const onApply = (api) => {
@@ -254,12 +279,6 @@ const onFixup = (api) => {
   startGitCommit(api, 'fixup');
 };
 
-const cancelCommit = (api) => {
-  api.ui.mode = 'review';
-  api.ui.composer.state.commitKind = null;
-  api.ui.status = '';
-};
-
 const finishAsyncCommit = (api, kind, message, done, write) => {
   const ui = api.ui;
   ui.composer.closeCompose();
@@ -323,6 +342,7 @@ const finishGitCommit = (api) => {
   if (isInPlaceCommit(kind) && briefCommit(ui)) {
     message = joinMessage(message, ui.composer.state.commitBody);
   }
+  message = tidyCommitMessage(message);
   if (!message.trim()) {
     ui.status = 'empty commit message';
     return;
@@ -360,12 +380,6 @@ const cancelDropCommit = (api) => {
   api.ui.status = '';
 };
 
-const dropAsync = (api, sha, done, write) => {
-  const run = (top) => write(top, sha);
-  const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.ui.ops.runBusy('dropping', done, run, after);
-};
-
 const confirmDropCommit = (api) => {
   const sha = api.state.dropSha;
   const name = api.state.dropName;
@@ -379,17 +393,9 @@ const confirmDropCommit = (api) => {
     api.ui.status = 'read only';
     return;
   }
-  const uiOpen = api.ui.uiOpen;
-  const picked = pickRepoWrite(repo, 'dropCommit', uiOpen);
-  if (picked.async) {
-    return void dropAsync(api, sha, done, picked.write);
-  }
-  const ok = api.ui.ops.runRepo(done, (top) => {
-    repo.dropCommit(top, sha);
-  });
-  if (!ok) return;
-  refreshAfterWrite(api);
-  if (!api.ui.status) api.ui.status = done;
+  api.ui.ops.runWrite('dropCommit', [sha], 'dropping', done, (extra) =>
+    refreshAfterWrite(api, extra),
+  );
 };
 
 const onView = (api) => {
@@ -428,8 +434,6 @@ const createCommitController = (ui) => {
       onCommitMove: (delta) => onCommitMove(api, delta),
       onShowDiff: () => showSelectedDiff(api),
       onView: () => onView(api),
-      cancelCommit: () => cancelCommit(api),
-      startGitCommit: (kind) => startGitCommit(api, kind),
       finishGitCommit: () => finishGitCommit(api),
       refresh: () => refreshCommitList(api),
       onDropCommit: () => onDropCommit(api),
@@ -441,7 +445,7 @@ const createCommitController = (ui) => {
 };
 
 module.exports = {
-  COMMIT_STATUS,
+  hasStagedChanges,
   createCommitController,
   listedCommits,
 };