reslop 0.1.9 → 0.2.0

package/lib/session/change-actions.js

@@ -1,10 +1,10 @@
 'use strict';
 
 const files = require('../files.js');
-const { listPath, isTodoItem, isTodosEntry } = files;
+const { listPath, isTodoItem, isTodosEntry, isReadOnlyOrigin } = files;
 const items = require('./items.js');
 const { needsReload, npmBusyKind, sameBlock } = items;
-const { isReadOnlyOrigin } = require('./origins.js');
+const { hunkKey } = require('../diff/diff.js');
 
 const nextUnstageOrigin = (item) => {
   if (item.file.isNew === true) return 'untracked';
@@ -25,27 +25,27 @@ const COMMANDS = {
   },
 };
 
-const keepOrigin = (options, item, origin) => {
-  options.collection.keepOrigin(item, origin);
-  const idx = options.collection.findRestoredIndex({ ...item, origin });
-  if (idx >= 0) options.nav.index = idx;
-  if (options.ignoreWatch) options.ignoreWatch();
-  options.nav.clearSelection();
-  options.syncReviewPath();
-  options.syncFileCursor();
+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.nav.clearSelection();
+  ui.syncReviewPath();
+  ui.syncFileCursor();
 };
 
-const fileCursorEntry = (options) => {
-  const list = options.fileList();
-  return list[options.nav.fileCursor] ?? null;
+const fileCursorEntry = (ui) => {
+  const list = ui.fileList();
+  return list[ui.nav.fileCursor] ?? null;
 };
 
-const fileActionItems = (options) => {
-  const entry = fileCursorEntry(options);
+const fileActionItems = (ui) => {
+  const entry = fileCursorEntry(ui);
   if (!entry || isTodosEntry(entry)) return [];
   const rel = entry.path;
   const selected = [];
-  for (const item of options.getItems()) {
+  for (const item of ui.items) {
     if (isTodoItem(item)) continue;
     if (listPath(item) !== rel) continue;
     selected.push(item);
@@ -53,29 +53,29 @@ const fileActionItems = (options) => {
   return selected;
 };
 
-const activeDiffItem = (options) => {
-  const item = options.currentItem();
+const activeDiffItem = (ui) => {
+  const item = ui.current();
   if (!item) return null;
   if (isTodoItem(item)) {
-    options.setStatus('not a diff block');
+    ui.status = 'not a diff block';
     return null;
   }
   return item;
 };
 
-const guardWritable = (options, item) => {
+const guardWritable = (ui, item) => {
   if (!item) return false;
-  const caps = options.capabilities();
+  const caps = ui.capabilities;
   if (!caps.changes || isReadOnlyOrigin(item.origin)) {
-    options.setStatus('read only');
+    ui.status = 'read only';
     return false;
   }
   return true;
 };
 
-const selectNextFileAfter = (options, rel) => {
-  const list = options.fileList();
-  const nav = options.nav;
+const selectNextFileAfter = (ui, rel) => {
+  const list = ui.fileList();
+  const nav = ui.nav;
   if (!list.length) {
     nav.fileCursor = 0;
     nav.reviewPath = null;
@@ -90,96 +90,96 @@ const selectNextFileAfter = (options, rel) => {
   nav.index = entry.firstIndex;
 };
 
-const liveItem = (options, item) => {
-  for (const entry of options.getItems()) {
+const liveItem = (ui, item) => {
+  for (const entry of ui.items) {
     if (sameBlock(entry, item)) return entry;
   }
   return item;
 };
 
-const applyGit = (options, item, label, write, after) => {
+const applyGit = (ui, item, label, write, after) => {
   try {
-    write(options.top(), item);
-    options.setStatus(label);
+    write(ui.top, item);
+    ui.status = label;
     after();
   } catch (error) {
-    options.setStatus(error.message);
+    ui.status = error.message;
   }
 };
 
-const applyFileGit = (options, targets, label, write, afterItem) => {
-  const completed = [];
+const applyFileGit = (ui, targets, label, write, afterItem) => {
+  const { length } = targets;
+  const completed = new Array(length);
+  let n = 0;
   try {
-    for (const item of targets) {
-      const current = liveItem(options, item);
-      write(options.top(), current);
+    for (let i = 0; i < length; i++) {
+      const current = liveItem(ui, targets[i]);
+      write(ui.top, current);
       afterItem(current);
-      completed.push(current);
+      completed[n++] = current;
     }
-    options.setStatus(label);
+    completed.length = n;
+    ui.status = label;
     return { ok: true, completed };
   } catch (error) {
-    options.setStatus(error.message);
+    completed.length = n;
+    ui.status = error.message;
     return { ok: false, completed };
   }
 };
 
-const reconcilePartial = (options, result) => {
+const reconcilePartial = (ui, result) => {
   if (result.ok) return false;
-  if (result.completed.length) options.reloadAfterChange();
+  if (result.completed.length) ui.reloadAfterChange();
   return true;
 };
 
-const applyBlockAdd = (options, item) => {
-  if (needsReload(item)) {
-    options.reloadAfterChange();
-    return;
-  }
-  keepOrigin(options, item, 'staged');
+const applyBlockAdd = (ui, item) => {
+  if (needsReload(item)) return void ui.reloadAfterChange();
+  keepOrigin(ui, item, 'staged');
 };
 
-const onBlockAdd = (options, item) => {
+const onBlockAdd = (ui, item) => {
   const busy = npmBusyKind(item);
-  const repo = options.repo();
-  if (options.uiOpen() && busy && repo.addAsync) {
-    const after = () => applyBlockAdd(options, item);
+  const repo = ui.repo;
+  if (ui.uiOpen && busy && repo.addAsync) {
+    const after = () => applyBlockAdd(ui, item);
     const write = (top) => repo.addAsync(top, item);
-    options.runBusy(busy, 'staged', write, after);
-    return;
+    return void ui.ops.runBusy(busy, 'staged', write, after);
   }
   applyGit(
-    options,
+    ui,
     item,
     'staged',
     (top, current) => repo.add(top, current),
     () => {
-      applyBlockAdd(options, item);
+      applyBlockAdd(ui, item);
     },
   );
 };
 
-const onBlockUnstage = (options, item) => {
+const onBlockUnstage = (ui, item) => {
   const origin = nextUnstageOrigin(item);
-  const repo = options.repo();
+  const repo = ui.repo;
   applyGit(
-    options,
+    ui,
     item,
     'unstaged',
     (top, current) => repo.unstage(top, current),
-    () => keepOrigin(options, item, origin),
+    () => keepOrigin(ui, item, origin),
   );
 };
 
-const onBlockRevert = (options, item) => {
-  const repo = options.repo();
+const onBlockRevert = (ui, item) => {
+  const repo = ui.repo;
   applyGit(
-    options,
+    ui,
     item,
     'dropped',
     (top, current) => repo.revert(top, current),
     () => {
-      if (needsReload(item)) options.collection.dismiss(item);
-      options.reloadAfterChange();
+      if (needsReload(item)) ui.collection.dismiss(item);
+      ui.reloadAfterChange();
     },
   );
 };
@@ -190,116 +190,114 @@ const BLOCK = {
   revert: onBlockRevert,
 };
 
-const onBlockCommand = (options, name) => {
+const onBlockCommand = (ui, name) => {
   const command = COMMANDS[name];
-  const item = activeDiffItem(options);
-  if (!guardWritable(options, item)) return;
+  const item = activeDiffItem(ui);
+  if (!guardWritable(ui, item)) return;
   if (!command.match(item)) {
-    options.setStatus(command.skipStatus);
+    ui.status = command.skipStatus;
     return;
   }
-  BLOCK[name](options, item);
+  BLOCK[name](ui, item);
 };
 
-const writeFileAddAsync = (options, targets) => async (top) => {
-  const repo = options.repo();
+const writeFileAddAsync = (ui, targets) => async (top) => {
+  const repo = ui.repo;
   for (const item of targets) {
-    const current = liveItem(options, item);
+    const current = liveItem(ui, item);
     await repo.addAsync(top, current);
-    keepOrigin(options, current, 'staged');
+    keepOrigin(ui, current, 'staged');
   }
 };
 
-const afterFileAdd = (options, rel, proposed) => () => {
+const afterFileAdd = (ui, rel, proposed) => () => {
   if (proposed) {
-    options.reloadAfterChange(() => selectNextFileAfter(options, rel));
-    return;
+    return void ui.reloadAfterChange(() => selectNextFileAfter(ui, rel));
   }
-  selectNextFileAfter(options, rel);
+  selectNextFileAfter(ui, rel);
 };
 
-const onFileAdd = (options) => {
-  const selected = fileActionItems(options);
+const onFileAdd = (ui) => {
+  const selected = fileActionItems(ui);
   if (!selected.length) {
-    options.setStatus('not a diff block');
+    ui.status = 'not a diff block';
     return;
   }
-  if (!guardWritable(options, selected[0])) return;
+  if (!guardWritable(ui, selected[0])) return;
   const rel = listPath(selected[0]);
   const targets = selected.filter(COMMANDS.add.match);
   if (!targets.length) {
-    options.setStatus('already staged');
-    selectNextFileAfter(options, rel);
+    ui.status = 'already staged';
+    selectNextFileAfter(ui, rel);
     return;
   }
   const proposed = targets.some(needsReload);
   const busy = targets.map(npmBusyKind).find((kind) => kind);
-  const repo = options.repo();
-  if (options.uiOpen() && busy && repo.addAsync) {
-    const write = writeFileAddAsync(options, targets);
-    const after = afterFileAdd(options, rel, proposed);
-    options.runBusy(busy, 'staged', write, after);
-    return;
+  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(
-    options,
+    ui,
     targets,
     'staged',
     (top, current) => repo.add(top, current),
-    (item) => keepOrigin(options, item, 'staged'),
+    (item) => keepOrigin(ui, item, 'staged'),
   );
-  if (reconcilePartial(options, result)) return;
-  if (proposed) options.reloadAfterChange();
-  selectNextFileAfter(options, rel);
+  if (reconcilePartial(ui, result)) return;
+  if (proposed) ui.reloadAfterChange();
+  selectNextFileAfter(ui, rel);
 };
 
-const onFileUnstage = (options) => {
-  const selected = fileActionItems(options);
+const onFileUnstage = (ui) => {
+  const selected = fileActionItems(ui);
   if (!selected.length) {
-    options.setStatus('not a diff block');
+    ui.status = 'not a diff block';
     return;
   }
-  if (!guardWritable(options, selected[0])) return;
+  if (!guardWritable(ui, selected[0])) return;
   const rel = listPath(selected[0]);
   const targets = selected.filter(COMMANDS.unstage.match);
   if (!targets.length) {
-    options.setStatus('not staged');
-    selectNextFileAfter(options, rel);
+    ui.status = 'not staged';
+    selectNextFileAfter(ui, rel);
     return;
   }
-  const repo = options.repo();
+  const repo = ui.repo;
   const result = applyFileGit(
-    options,
+    ui,
     targets,
     'unstaged',
     (top, current) => repo.unstage(top, current),
-    (item) => keepOrigin(options, item, nextUnstageOrigin(item)),
+    (item) => keepOrigin(ui, item, nextUnstageOrigin(item)),
   );
-  if (reconcilePartial(options, result)) return;
-  selectNextFileAfter(options, rel);
+  if (reconcilePartial(ui, result)) return;
+  selectNextFileAfter(ui, rel);
 };
 
-const onFileRevert = (options) => {
-  const selected = fileActionItems(options);
+const onFileRevert = (ui) => {
+  const selected = fileActionItems(ui);
   if (!selected.length) {
-    options.setStatus('not a diff block');
+    ui.status = 'not a diff block';
     return;
   }
-  if (!guardWritable(options, selected[0])) return;
+  if (!guardWritable(ui, selected[0])) return;
   const rel = listPath(selected[0]);
   for (const item of selected) {
-    if (needsReload(item)) options.collection.dismiss(item);
+    if (needsReload(item)) ui.collection.dismiss(item);
   }
   let ok = false;
   try {
-    options.repo().revertFile(options.top(), rel, selected);
-    options.setStatus('dropped');
+    ui.repo.revertFile(ui.top, rel, selected);
+    ui.status = 'dropped';
     ok = true;
   } catch (error) {
-    options.setStatus(error.message);
+    ui.status = error.message;
   }
-  const after = ok ? () => selectNextFileAfter(options, rel) : null;
-  options.reloadAfterChange(after);
+  const after = ok ? () => selectNextFileAfter(ui, rel) : null;
+  ui.reloadAfterChange(after);
 };
 
 const FILE = {
@@ -308,16 +306,97 @@ const FILE = {
   revert: onFileRevert,
 };
 
-const onCommand = (options, name) => {
-  if (options.nav.pane === 'files') return void FILE[name](options);
-  onBlockCommand(options, name);
+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 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);
+  if (!guardWritable(ui, item)) return;
+  const selected = hunkActionItems(ui, item);
+  const targets = name === 'revert' ? selected : selected.filter(command.match);
+  if (!targets.length) {
+    ui.status = command.skipStatus ?? 'not a diff block';
+    return;
+  }
+  UNIT[name](ui, targets);
+};
+
+const onCommand = (ui, name) => {
+  if (ui.nav.pane === 'files') return void FILE[name](ui);
+  if (ui.nav.pane === 'unit') return void onUnitCommand(ui, name);
+  onBlockCommand(ui, name);
 };
 
-const createChangeActions = (options) => ({
-  fileCursorEntry: () => fileCursorEntry(options),
-  onAdd: () => onCommand(options, 'add'),
-  onUnstage: () => onCommand(options, 'unstage'),
-  onRevert: () => onCommand(options, 'revert'),
+const createChangeActions = (ui) => ({
+  fileCursorEntry: () => fileCursorEntry(ui),
+  onAdd: () => onCommand(ui, 'add'),
+  onUnstage: () => onCommand(ui, 'unstage'),
+  onRevert: () => onCommand(ui, 'revert'),
 });
 
 module.exports = { createChangeActions };