reslop 0.1.9 → 0.2.0

package/lib/session/review.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const store = require('../review/store.js');
-const { createStore, applyImportedNotes, setStatus } = store;
-const storage = require('../review/storage.js');
-const { listReviewNames, loadTemplates, resolveReviewPath } = storage;
-const { loadReview, flushReview } = storage;
+const { stateView } = require('./accessors.js');
 
-const createReviewController = (options) => {
-  const io = options.storage;
+const review = require('../review.js');
+const { createStore, applyImportedNotes, setStatus } = review;
+const { listReviewNames, loadTemplates, resolveReviewPath } = review;
+const { loadReview, flushReview } = review;
+
+const createReviewController = () => {
   const state = {
     store: null,
     didResume: false,
@@ -21,15 +21,11 @@ const createReviewController = (options) => {
   };
 
   const init = (dir, date, extra = {}) => {
-    const forceNew = extra.forceNew ?? false;
-    const names = listReviewNames(dir, io.readdirSync);
-    const templates = loadTemplates(dir, io.readFileSync);
-    const resolved = resolveReviewPath(dir, date, names, {
-      forceNew,
-      readFileSync: io.readFileSync,
-    });
+    const names = listReviewNames(dir);
+    const templates = loadTemplates(dir);
+    const resolved = resolveReviewPath(dir, date, names, extra);
     if (resolved.resume) {
-      state.store = loadReview(resolved.reviewPath, templates, io.readFileSync);
+      state.store = loadReview(resolved.reviewPath, templates);
       state.didResume = true;
       return state.store;
     }
@@ -49,13 +45,7 @@ const createReviewController = (options) => {
   const flush = (force = false) => {
     if (!state.store) return { ok: true, wrote: false };
     try {
-      const writeFileSync = io.writeFileSync;
-      const mkdirSync = io.mkdirSync;
-      const wrote = flushReview(state.store, {
-        writeFileSync,
-        mkdirSync,
-        force,
-      });
+      const wrote = flushReview(state.store, force);
       return { ok: true, wrote };
     } catch (error) {
       return { ok: false, wrote: false, error };
@@ -67,22 +57,18 @@ const createReviewController = (options) => {
     return flush();
   };
 
-  return {
-    get store() {
-      return state.store;
-    },
-    get didResume() {
-      return state.didResume;
+  return stateView(
+    state,
+    {
+      reset,
+      init,
+      applyImported,
+      flush,
+      finishQuit,
     },
-    get importedRemote() {
-      return state.importedRemote;
-    },
-    reset,
-    init,
-    applyImported,
-    flush,
-    finishQuit,
-  };
+    [],
+    ['store', 'didResume', 'importedRemote'],
+  );
 };
 
 module.exports = { createReviewController };

package/lib/session/terminal.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const { presentRows, presentCursor } = require('../render.js');
-const { listen, watchResize } = require('../sys.js');
+const { presentRows, presentCursor } = require('../render/render.js');
+const { listen, watchResize } = require('../utilities.js');
 
 const ENTER_TERM = '\x1b[?1049h\x1b[?25l\x1b[?7l\x1b[?1002h\x1b[?1006h';
 const LEAVE_TERM =
@@ -18,14 +18,16 @@ const hasTimer = (api, name) => api.timers.has(name);
 const stopTimer = (api, name) => {
   const id = api.timers.get(name);
   if (id === undefined) return;
-  api.clearIntervalFn(id);
+  clearInterval(id);
   api.timers.delete(name);
 };
 
 const startTimer = (api, name, fn, ms) => {
   if (api.state.disposed) return;
   if (api.timers.has(name)) return;
-  api.timers.set(name, api.setIntervalFn(fn, ms));
+  const id = setInterval(fn, ms);
+  if (id && typeof id.unref === 'function') id.unref();
+  api.timers.set(name, id);
 };
 
 const restartTimer = (api, name, fn, ms) => {
@@ -118,8 +120,6 @@ const createTerminal = (options) => {
     stdin: options.stdin ?? null,
     stdout: options.stdout,
     proc: options.proc ?? process,
-    setIntervalFn: options.setInterval ?? setInterval,
-    clearIntervalFn: options.clearInterval ?? clearInterval,
     timers: new Map(),
     disposers: [],
     state,
@@ -131,18 +131,12 @@ const createTerminal = (options) => {
     get lastSize() {
       return state.lastSize;
     },
-    get lastPresentedCursor() {
-      return state.lastPresentedCursor;
-    },
     get carry() {
       return state.carry;
     },
     set carry(value) {
       state.carry = value;
     },
-    get isOpen() {
-      return state.open;
-    },
     get disposed() {
       return state.disposed;
     },

package/lib/session/todos.js

@@ -48,17 +48,19 @@ const isDraftCompose = (api) => {
 const todoTexts = (api) => {
   const nav = api.nav;
   if (!nav.todoOpen) return [];
-  const texts = [];
+  const todos = listTodos(api);
+  const texts = new Array(todos.length + 1);
   const { state } = api;
   const editingTodo = state.composeKind === 'todo';
   const editingId = editingTodo ? state.composeTodoId : null;
-  for (const todo of listTodos(api)) {
+  for (let i = 0; i < todos.length; i++) {
+    const todo = todos[i];
     const live = editingId === todo.id && state.editor;
     const text = live ? state.editor.text : todo.text;
-    texts.push(checkLabel(text, todo.done));
+    texts[i] = checkLabel(text, todo.done);
   }
   const draft = isDraftCompose(api) && state.editor ? state.editor.text : '';
-  texts.push(checkLabel(draft, false));
+  texts[todos.length] = checkLabel(draft, false);
   return texts;
 };
 
@@ -126,10 +128,7 @@ const editFocusedTodo = (api) => {
   if (!api.nav.todoOpen) return;
   const todos = listTodos(api);
   const todo = todos[clampedTodoFocus(api)];
-  if (!todo) {
-    startDraftCompose(api);
-    return;
-  }
+  if (!todo) return void startDraftCompose(api);
   api.open('todo', todo.text, todo.id);
 };
 
@@ -234,10 +233,7 @@ const commitTodo = (api, text) => {
   const id = api.state.composeTodoId;
   const todos = notes.todos;
   const prev = id === null ? null : todos.find((entry) => entry.id === id);
-  if (prev) {
-    setTodoText(notes, id, text);
-    return;
-  }
+  if (prev) return void setTodoText(notes, id, text);
   if (!text.trim()) return;
   const todo = addTodo(notes, TODO_FILE, text);
   api.state.composeTodoId = todo.id;

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, 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,9 +160,12 @@ 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,
@@ -128,4 +197,4 @@ const createView = (api) => ({
   view: () => view(api),
 });
 
-module.exports = { SOURCE_KIND, relabelStatus, createView };
+module.exports = { relabelStatus, createView };