reslop 0.1.8 → 0.2.0

package/lib/session/unit.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const files = require('../files.js');
+const { listPath, isTodosEntry } = files;
+const diff = require('../diff/diff.js');
+const { unitLines, itemsForPath, blockLineIndex } = diff;
+const { hunkLineRange, sameHunk, hunkKey } = diff;
+const { fileOffset, splitEditor, mergeEditRows, fileLineIndex } = diff;
+
+const fileText = (ui, rel) => {
+  if (!rel) return '';
+  const repo = ui.repo;
+  if (repo && typeof repo.fileText === 'function') {
+    return repo.fileText(ui.top, rel, ui.rev);
+  }
+  return '';
+};
+
+const pathItems = (ui, rel) => itemsForPath(ui.items ?? [], rel);
+
+const linesFor = (
+  ui,
+  rel,
+  overlay = ui.composer.liveFileText(),
+  base = null,
+) => {
+  const text = overlay === null ? fileText(ui, rel) : overlay;
+  const group = pathItems(ui, rel);
+  if (overlay !== null && base && base.length) {
+    return mergeEditRows(base, splitEditor(text));
+  }
+  return unitLines(text, group);
+};
+
+const BODY_SHIFT = 1;
+
+const clampUnitLine = (nav, length) => {
+  if (!length) {
+    nav.unitLine = 0;
+    return;
+  }
+  if (nav.unitLine < 0) nav.unitLine = 0;
+  if (nav.unitLine >= length) nav.unitLine = length - 1;
+};
+
+const CONTEXT = 1;
+
+const frameBodyH = (frame, ui) => {
+  if (frame && frame.bodyH) return frame.bodyH;
+  const size = ui?.lastSize ?? ui?.getSize?.();
+  const height = size && size.height ? size.height : 24;
+  return Math.max(1, height - 4);
+};
+
+const ensureRangeVisible = (nav, firstLine, lastLine, frame, ui) => {
+  const bodyH = frameBodyH(frame, ui);
+  const diffFirst = firstLine + BODY_SHIFT;
+  const diffLast = lastLine + BODY_SHIFT;
+  const diffSpan = diffLast - diffFirst + 1;
+  let first = diffFirst;
+  let last = diffLast;
+  if (diffSpan <= bodyH) {
+    const padFirst = Math.max(0, firstLine - CONTEXT) + BODY_SHIFT;
+    const padLast = lastLine + CONTEXT + BODY_SHIFT;
+    if (padLast - padFirst + 1 <= bodyH) {
+      first = padFirst;
+      last = padLast;
+    }
+  }
+  const span = last - first + 1;
+  let scroll = nav.scroll ?? 0;
+  if (span > bodyH) {
+    scroll = first;
+  } else {
+    if (first < scroll) scroll = first;
+    const viewLast = scroll + bodyH - 1;
+    if (last > viewLast) scroll = last - bodyH + 1;
+  }
+  nav.scroll = Math.max(0, scroll);
+};
+
+const ensureVisible = (nav, length, frame) => {
+  clampUnitLine(nav, length);
+  ensureRangeVisible(nav, nav.unitLine, nav.unitLine, frame);
+};
+
+const followFileCursor = (nav, editor, frame, rows) => {
+  if (!editor) return;
+  const fileLine = editor.linePos().line;
+  if (rows && rows.length) {
+    nav.unitLine = fileLineIndex(rows, fileLine);
+    ensureVisible(nav, rows.length, frame);
+    return;
+  }
+  const length = `${editor.text}`.split('\n').length;
+  nav.unitLine = fileLine;
+  ensureVisible(nav, length, frame);
+};
+
+const jumpToItem = (ui, item) => {
+  const nav = ui.nav;
+  const rel = nav.reviewPath;
+  const lines = linesFor(ui, rel);
+  const items = ui.items ?? [];
+  const idx = items.indexOf(item);
+  if (idx >= 0) nav.index = idx;
+  const range = hunkLineRange(lines, item);
+  nav.unitLine = range.start;
+  ensureRangeVisible(nav, range.start, range.end, ui.lastFrame, ui);
+};
+
+const viewLine = (nav, length) => {
+  if (!length) return 0;
+  const top = Math.max(0, (nav.scroll ?? 0) - 1);
+  return Math.min(top, length - 1);
+};
+
+const moveUnitBlock = (ui, step) => {
+  const nav = ui.nav;
+  const rel = nav.reviewPath;
+  if (!rel) return;
+  const items = ui.items ?? [];
+  const indexes = [];
+  const seen = new Set();
+  for (let i = 0; i < items.length; i++) {
+    if (listPath(items[i]) !== rel) continue;
+    const key = hunkKey(items[i]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    indexes.push(i);
+  }
+  if (!indexes.length) {
+    ui.status = 'not a diff block';
+    return;
+  }
+  let at = -1;
+  const current = items[nav.index];
+  for (let i = 0; i < indexes.length; i++) {
+    if (!sameHunk(items[indexes[i]], current)) continue;
+    at = i;
+    break;
+  }
+  if (at < 0) at = step > 0 ? -1 : 0;
+  const next = at + step;
+  if (next < 0 || next >= indexes.length) return;
+  const item = items[indexes[next]];
+  jumpToItem(ui, item);
+  ui.status = '';
+  nav.clearSelection();
+};
+
+const openUnitFile = (ui, entry) => {
+  if (!entry || isTodosEntry(entry)) return;
+  const nav = ui.nav;
+  nav.reviewPath = entry.path;
+  nav.todoOpen = false;
+  nav.pane = 'unit';
+  nav.scroll = 0;
+  nav.unitLine = 0;
+  nav.clearSelection();
+  const items = ui.items ?? [];
+  const group = pathItems(ui, entry.path);
+  if (group.length) {
+    const want = items[entry.openIndex] ?? items[entry.firstIndex] ?? group[0];
+    const item = group.includes(want) ? want : group[0];
+    jumpToItem(ui, item);
+  } else {
+    nav.unitLine = 0;
+  }
+  ui.status = '';
+};
+
+const setFileScope = (ui, next) => {
+  if (ui.nav.pane !== 'files') return;
+  if (ui.nav.fileScope === next) return;
+  ui.nav.fileScope = next;
+  ui.nav.restoreFileCursor(ui.fileList());
+  ui.status = next === 'file' ? 'file scope' : 'diff mode';
+};
+
+const editCursor = (ui) => {
+  const rel = ui.nav.reviewPath;
+  const text = fileText(ui, rel);
+  const group = pathItems(ui, rel);
+  const lines = unitLines(text, group);
+  const items = ui.items ?? [];
+  const item = items[ui.nav.index];
+  const atBlock = item && listPath(item) === rel;
+  const at = atBlock
+    ? blockLineIndex(lines, item)
+    : viewLine(ui.nav, lines.length);
+  return {
+    text,
+    cursor: fileOffset(lines, at),
+    rows: lines,
+  };
+};
+
+module.exports = {
+  fileText,
+  linesFor,
+  moveUnitBlock,
+  openUnitFile,
+  setFileScope,
+  editCursor,
+  ensureVisible,
+  followFileCursor,
+};

package/lib/session/update.js

@@ -1,10 +1,12 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const update = require('../update.js');
 const { checkUpdate, installUpdate, markSkipped } = update;
 
 const optsOf = (api) => {
-  const value = api.options.updateOpts();
+  const value = api.ui.updateOpts;
   if (!value || value === true) return {};
   return value;
 };
@@ -19,15 +21,16 @@ const reset = (state) => {
 
 const maybePrompt = (api) => {
   if (!api.state.offer) return;
-  if (!api.options.didLoad()) return;
-  if (api.options.getMode() !== 'review') return;
-  api.options.setMode('confirmUpdate');
+  if (!api.ui.loader.didLoad) return;
+  if (api.ui.mode !== 'review') return;
+  api.ui.mode = 'confirmUpdate';
 };
 
 const runInstall = async (api, version) => {
-  api.options.setStatus('updating reslop');
-  api.options.startInstallProgress();
-  api.options.paint();
+  api.ui.status = 'updating reslop';
+  api.ui.progressFrame = 0;
+  api.ui.progress.start('install');
+  api.ui.paint();
   let ok = false;
   try {
     await installUpdate(version, optsOf(api));
@@ -35,23 +38,23 @@ const runInstall = async (api, version) => {
   } catch {
     // ignore install errors
   }
-  api.options.stopInstallProgress();
-  if (api.options.isDone() || !api.options.uiOpen()) return;
-  api.options.setStatus(ok ? 'updated' : 'update failed');
-  api.options.paint();
+  api.ui.progress.stop('install');
+  if (api.ui.done || !api.ui.uiOpen) return;
+  api.ui.status = ok ? 'updated' : 'update failed';
+  api.ui.paint();
 };
 
 const acceptUpdate = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.offer = false;
   const version = api.state.to;
   api.state.installPromise = runInstall(api, version);
 };
 
 const declineUpdate = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.offer = false;
-  api.options.setStatus('');
+  api.ui.status = '';
   markSkipped(api.state.to, optsOf(api));
 };
 
@@ -62,7 +65,7 @@ const runOpenUpdate = async (api) => {
   } catch {
     return;
   }
-  if (api.options.isDone()) return;
+  if (api.ui.done) return;
   if (plan.action === 'install') {
     api.state.installPromise = runInstall(api, plan.latest);
     await api.state.installPromise;
@@ -73,17 +76,17 @@ const runOpenUpdate = async (api) => {
   api.state.to = plan.latest;
   api.state.offer = true;
   maybePrompt(api);
-  api.options.paint();
+  api.ui.paint();
 };
 
 const openUpdate = (api) => {
-  if (api.options.updateOpts() === false) return Promise.resolve();
+  if (api.ui.updateOpts === false) return Promise.resolve();
   if (api.state.checkPromise) return api.state.checkPromise;
   api.state.checkPromise = runOpenUpdate(api);
   return api.state.checkPromise;
 };
 
-const createUpdateCoordinator = (options) => {
+const createUpdateCoordinator = (ui) => {
   const state = {
     offer: false,
     from: '',
@@ -91,35 +94,19 @@ const createUpdateCoordinator = (options) => {
     checkPromise: null,
     installPromise: null,
   };
-  const api = { options, state };
-  return {
-    get offer() {
-      return state.offer;
-    },
-    set offer(value) {
-      state.offer = value;
-    },
-    get from() {
-      return state.from;
-    },
-    get to() {
-      return state.to;
+  const api = { ui, state };
+  return stateView(
+    state,
+    {
+      reset: () => reset(state),
+      maybePrompt: () => maybePrompt(api),
+      accept: () => acceptUpdate(api),
+      decline: () => declineUpdate(api),
+      open: () => openUpdate(api),
     },
-    get checkPromise() {
-      return state.checkPromise;
-    },
-    get installPromise() {
-      return state.installPromise;
-    },
-    set installPromise(value) {
-      state.installPromise = value;
-    },
-    reset: () => reset(state),
-    maybePrompt: () => maybePrompt(api),
-    accept: () => acceptUpdate(api),
-    decline: () => declineUpdate(api),
-    open: () => openUpdate(api),
-  };
+    ['offer', 'installPromise'],
+    ['from', 'to', 'checkPromise'],
+  );
 };
 
 module.exports = { createUpdateCoordinator };

package/lib/session/view.js

@@ -6,11 +6,8 @@ const files = require('../files.js');
 const { fileEntries, REPO_TODOS_LABEL } = files;
 const review = require('../review.js');
 const { noteCounts } = review;
-
-const SOURCE_KIND = {
-  'github-pr': 'pr',
-  'gitlab-mr': 'mr',
-};
+const diff = require('../diff/diff.js');
+const { unitLines, itemsForPath, splitEditor, mergeEditRows } = diff;
 
 const relabelStatus = (entries, from, to) => {
   if (!to) return entries;
@@ -43,14 +40,60 @@ const todosEntry = (counts) => ({
   unstaged: 0,
 });
 
+const blankEntry = (rel) => ({
+  path: rel,
+  origins: [],
+  firstIndex: 0,
+  openIndex: 0,
+  remaining: 0,
+  added: 0,
+  removed: 0,
+  stagedAdded: 0,
+  stagedRemoved: 0,
+  unstagedAdded: 0,
+  unstagedRemoved: 0,
+  staged: 0,
+  unstaged: 0,
+  date: '',
+  status: '',
+});
+
+const listedNames = (api) => {
+  const repo = api.ui.repo;
+  if (!repo || typeof repo.listFiles !== 'function') return [];
+  try {
+    return repo.listFiles(api.ui.top || api.ui.cwd, api.ui.paths ?? [], {
+      commit: api.ui.rev,
+    });
+  } catch {
+    return [];
+  }
+};
+
+const mergeUnitFiles = (entries, names) => {
+  const have = new Set();
+  for (const entry of entries) have.add(entry.path);
+  const extra = [];
+  for (const rel of names) {
+    if (!rel || have.has(rel)) continue;
+    extra.push(blankEntry(rel));
+  }
+  const merged = [...entries, ...extra];
+  merged.sort((left, right) => left.path.localeCompare(right.path, 'en'));
+  return merged;
+};
+
 const fileList = (api, notes = noteCounts(api.review.store)) => {
   const entries = fileEntries(api.collection.items);
   const sourceLabel = api.ui.sourceLabel;
   const from = sourceLabel ? 'pr' : 'commit';
   const to = sourceLabel || api.ui.revShort;
   const labeled = relabelStatus(entries, from, to);
-  labeled.unshift(todosEntry(notes));
-  return labeled;
+  const names = listedNames(api);
+  const scoped =
+    api.nav.fileScope === 'file' ? mergeUnitFiles(labeled, names) : labeled;
+  scoped.unshift(todosEntry(notes));
+  return scoped;
 };
 
 const counts = (api, notes = noteCounts(api.review.store)) => {
@@ -76,11 +119,34 @@ const counts = (api, notes = noteCounts(api.review.store)) => {
 
 const viewStatus = (api) => api.ui.status || api.ui.busy;
 
+const unitFileText = (api) => {
+  const rel = api.nav.reviewPath;
+  if (!rel) return '';
+  const repo = api.ui.repo;
+  if (repo && typeof repo.fileText === 'function') {
+    return repo.fileText(api.ui.top, rel, api.ui.rev);
+  }
+  return '';
+};
+
+const unitBodyLines = (api) => {
+  if (api.nav.pane !== 'unit') return [];
+  const rel = api.nav.reviewPath;
+  const group = itemsForPath(api.collection.items, rel);
+  const live = api.composer.liveFileText();
+  if (live !== null) {
+    const base = api.composer.fileEditRows();
+    if (base && base.length) return mergeEditRows(base, splitEditor(live));
+    return mergeEditRows(unitLines(live, group), splitEditor(live));
+  }
+  return unitLines(unitFileText(api), group);
+};
+
 const view = (api) => {
-  const { composer, nav, ui, gitBranches, updater } = api;
+  const { composer, nav, ui, gitBranches, commits, updater } = api;
   const templates = composer.shownTemplates();
   const change = ui.change;
-  const sourceKind = (change && SOURCE_KIND[change.source]) || '';
+  const sourceKind = (change && change.source) || '';
   const notes = noteCounts(api.review.store);
   return {
     item: ui.current(),
@@ -94,12 +160,17 @@ const view = (api) => {
     counts: counts(api, notes),
     selection: nav.selection,
     pane: nav.pane,
+    fileScope: nav.fileScope,
     files: fileList(api, notes),
     fileCursor: nav.fileCursor,
     reviewPath: nav.reviewPath,
+    unitLine: nav.unitLine,
+    unitLines: unitBodyLines(api),
     branch: ui.branch,
     branches: gitBranches.branches,
     branchCursor: nav.branchCursor,
+    commits: commits.commits,
+    commitCursor: nav.commitCursor,
     repoName: repoNameOf(api),
     revShort: ui.revShort || '',
     sourceLabel: ui.sourceLabel || '',
@@ -115,7 +186,7 @@ const view = (api) => {
     templateIndex: composer.clampedTemplateIndex(templates),
     updateFrom: updater.from,
     updateTo: updater.to,
-    dropName: gitBranches.dropName,
+    dropName: gitBranches.dropName || commits.dropName,
   };
 };
 
@@ -126,4 +197,4 @@ const createView = (api) => ({
   view: () => view(api),
 });
 
-module.exports = { SOURCE_KIND, relabelStatus, createView };
+module.exports = { relabelStatus, createView };

package/lib/session/watch.js

@@ -74,12 +74,13 @@ const closeWatcher = (watcher) => {
 
 const schedule = (state) => {
   if (state.closed) return;
-  if (state.timer !== null) state.clearTimeoutFn(state.timer);
-  state.timer = state.setTimeoutFn(() => {
+  if (state.timer !== null) clearTimeout(state.timer);
+  state.timer = setTimeout(() => {
     state.timer = null;
     if (state.closed) return;
     state.onChange();
   }, state.debounceMs);
+  if (typeof state.timer.unref === 'function') state.timer.unref();
 };
 
 const handleWatchEvent = (state, dir, eventType, filename) => {
@@ -100,9 +101,9 @@ const watchOne = (state, target, extra = {}) => {
     const onEvent = (eventType, filename) => {
       handleWatchEvent(state, target, eventType, filename);
     };
-    const watcher = state.watchFn(
+    const watcher = fs.watch(
       target,
-      { persistent: true, encoding: 'utf8', ...extra },
+      { persistent: false, encoding: 'utf8', ...extra },
       onEvent,
     );
     if (typeof watcher.on === 'function') {
@@ -120,7 +121,7 @@ const watchTree = (state, dir) => {
   if (state.recursive) return;
   let entries;
   try {
-    entries = state.readdirSync(dir, { withFileTypes: true });
+    entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -135,7 +136,7 @@ const maybeWatchNewDir = (state, full) => {
   if (state.recursive) return;
   let stat;
   try {
-    stat = state.statSync(full);
+    stat = fs.statSync(full);
   } catch {
     return;
   }
@@ -148,15 +149,11 @@ const watchScope = (state, spec) => {
   const target = path.resolve(state.root, spec);
   let stat;
   try {
-    stat = state.statSync(target);
+    stat = fs.statSync(target);
   } catch {
-    watchOne(state, path.dirname(target));
-    return;
-  }
-  if (stat.isDirectory()) {
-    watchTree(state, target);
-    return;
+    return void watchOne(state, path.dirname(target));
   }
+  if (stat.isDirectory()) return void watchTree(state, target);
   watchOne(state, path.dirname(target));
 };
 
@@ -168,7 +165,7 @@ const watchGit = (state) => {
 
 const stopState = (state) => {
   state.closed = true;
-  if (state.timer !== null) state.clearTimeoutFn(state.timer);
+  if (state.timer !== null) clearTimeout(state.timer);
   state.timer = null;
   while (state.watchers.length) closeWatcher(state.watchers.pop());
   state.watched.clear();
@@ -186,11 +183,6 @@ const createDiskWatcher = (options) => {
   const recursive = options.recursive ?? canWatchRecursive();
   const state = {
     root: path.resolve(options.root),
-    watchFn: options.watch ?? fs.watch,
-    readdirSync: options.readdirSync ?? fs.readdirSync,
-    statSync: options.statSync ?? fs.statSync,
-    setTimeoutFn: options.setTimeout ?? setTimeout,
-    clearTimeoutFn: options.clearTimeout ?? clearTimeout,
     debounceMs: options.debounceMs ?? DEBOUNCE_MS,
     onChange: options.onChange,
     recursive,