reslop 0.1.8 → 0.2.0

package/lib/session.js

@@ -1,16 +1,15 @@
 'use strict';
 
-const render = require('./render.js');
+const render = require('./render/render.js');
 const keys = require('./keys.js');
 const review = require('./review.js');
-const { copyText } = require('./clipboard.js');
 const files = require('./files.js');
 const { makeTodoItem } = files;
 const { renderFrame } = render;
 const { decodeChunk } = keys;
 const { AUTOSAVE_MS, hasNotes } = review;
 const capabilities = require('./capabilities.js');
-const { sessionCapabilities, createReviewStorage } = capabilities;
+const { sessionCapabilities } = capabilities;
 const { createTerminal, LEAVE_TERM } = require('./session/terminal.js');
 const { createLoadCoordinator } = require('./session/load.js');
 const items = require('./session/items.js');
@@ -35,16 +34,17 @@ const { createDispatcher, createInput } = require('./session/dispatch.js');
 const CURSOR_BLINK_MS = 500;
 const PROGRESS_MS = 80;
 
-const systemNow = () => new Date();
-
 const NAV_FIELDS = [
   'pane',
   'index',
   'fileCursor',
   'branchCursor',
+  'commitCursor',
   'scroll',
   'listScroll',
   'reviewPath',
+  'fileScope',
+  'unitLine',
   'selection',
   'mouseAnchor',
   'pendingClick',
@@ -71,51 +71,34 @@ const assignOptions = (session, options) => {
   session.stdout = options.stdout;
   session.proc = options.proc ?? process;
   session.color = options.color ?? true;
-  session.copyText = options.copyText ?? copyText;
-  const termSize = () => {
+  session.getSize = () => {
     const width = session.stdout.columns ?? 80;
     const height = session.stdout.rows ?? 24;
     return { width, height };
   };
-  session.getSize = options.getSize ?? termSize;
   session.rev = options.rev ?? null;
   session.revShort = '';
   session.sourceLabel = options.sourceLabel ?? '';
   session.repoName = options.repoName ?? '';
   session.change = options.change ?? null;
-  session.now = options.now ?? systemNow;
   session.forceNewReview = options.newReview === true;
   session.readOnly = options.readOnly === true;
   session.capabilities = sessionCapabilities(options);
-  const storage = options.reviewStorage ?? createReviewStorage(options);
   session.audit = options.audit === true;
   session.outdatedMap = options.outdatedMap;
   session.auditMap = options.auditMap;
-  session.setInterval = options.setInterval ?? setInterval;
-  session.clearInterval = options.clearInterval ?? clearInterval;
-  session.watchOpts = {
-    watch: options.watch,
-    readdirSync: options.watchReaddir,
-    statSync: options.watchStat,
-    setTimeout: options.setTimeout ?? setTimeout,
-    clearTimeout: options.clearTimeout ?? clearTimeout,
-    debounceMs: options.watchDebounceMs,
-    recursive: options.watchRecursive,
-  };
   session.updateOpts = options.update;
   session.term = createTerminal({
     stdin: session.stdin,
     stdout: session.stdout,
     proc: session.proc,
-    setInterval: session.setInterval,
-    clearInterval: session.clearInterval,
   });
   session.loader = createLoadCoordinator();
   session.collection = createItemCollection();
   session.nav = createNavigation({
     startPane: options.startPane ?? 'files',
   });
-  session.review = createReviewController({ storage });
+  session.review = createReviewController();
   session.progress = createProgress(
     session.term,
     () => session.tickProgress(),
@@ -123,28 +106,6 @@ const assignOptions = (session, options) => {
   );
 };
 
-const assignUpdater = (session) => {
-  session.updater = createUpdateCoordinator({
-    updateOpts: () => session.updateOpts,
-    didLoad: () => session.loader.didLoad,
-    getMode: () => session.mode,
-    setMode: (mode) => {
-      session.mode = mode;
-    },
-    isDone: () => session.done,
-    uiOpen: () => session.uiOpen,
-    paint: () => session.paint(),
-    setStatus: (value) => {
-      session.status = value;
-    },
-    startInstallProgress: () => {
-      session.progressFrame = 0;
-      session.progress.start('install');
-    },
-    stopInstallProgress: () => session.progress.stop('install'),
-  });
-};
-
 const assignComposer = (session) => {
   session.composer = createComposer({
     nav: session.nav,
@@ -162,73 +123,10 @@ const assignComposer = (session) => {
 };
 
 const assignControllers = (session) => {
-  const setStatus = (value) => {
-    session.status = value;
-  };
-  const setMode = (mode) => {
-    session.mode = mode;
-  };
-  session.ops = createOpsRunner({
-    top: () => session.top,
-    isDone: () => session.done,
-    getMode: () => session.mode,
-    setMode,
-    getStatus: () => session.status,
-    setStatus,
-    paint: () => session.paint(),
-    startProgress: () => session.startProgress(),
-    stopProgress: () => session.stopProgress(),
-    resetProgressFrame: () => {
-      session.progressFrame = 0;
-    },
-  });
-  session.changeActions = createChangeActions({
-    repo: () => session.repo,
-    top: () => session.top,
-    capabilities: () => session.capabilities,
-    uiOpen: () => session.uiOpen,
-    collection: session.collection,
-    getItems: () => session.items,
-    currentItem: () => session.current(),
-    nav: session.nav,
-    fileList: () => session.fileList(),
-    runBusy: session.ops.runBusy,
-    reloadAfterChange: (afterLoad) => session.reloadAfterChange(afterLoad),
-    setStatus,
-    syncReviewPath: () => session.syncReviewPath(),
-    syncFileCursor: () => session.syncFileCursor(),
-  });
-  session.commits = createCommitController({
-    repo: () => session.repo,
-    top: () => session.top,
-    capabilities: () => session.capabilities,
-    getItems: () => session.items,
-    uiOpen: () => session.uiOpen,
-    composer: session.composer,
-    collection: session.collection,
-    runner: session.ops,
-    refreshFromRepo: (opts) => session.refreshFromRepo(opts),
-    setMode,
-    setStatus,
-    isDone: () => session.done,
-    pendingExtras: () => session.pendingExtras,
-  });
-  session.gitBranches = createBranchController({
-    repo: () => session.repo,
-    top: () => session.top,
-    capabilities: () => session.capabilities,
-    uiOpen: () => session.uiOpen,
-    composer: session.composer,
-    nav: session.nav,
-    runner: session.ops,
-    canCommit: session.commits.canCommit,
-    refreshFromRepo: (opts) => session.refreshFromRepo(opts),
-    showFiles: () => session.showFiles(),
-    getMode: () => session.mode,
-    setMode,
-    getStatus: () => session.status,
-    setStatus,
-  });
+  session.ops = createOpsRunner(session);
+  session.changeActions = createChangeActions(session);
+  session.commits = createCommitController(session);
+  session.gitBranches = createBranchController(session);
 };
 
 const bindSessionAccessors = (session) => {
@@ -286,33 +184,12 @@ const bindViewer = (session) => {
     collection: session.collection,
     review: session.review,
     gitBranches: session.gitBranches,
+    commits: session.commits,
     updater: session.updater,
     ui: session,
   });
 };
 
-const bindFilesPane = (session) => {
-  session.filesPane = createFilesPane({
-    nav: session.nav,
-    composer: session.composer,
-    items: () => session.items,
-    todoItem: () => session.todoItem,
-    fileList: () => session.fileList(),
-    setStatus: (value) => {
-      session.status = value;
-    },
-    onQuit: () => session.onQuit(),
-    onCheckoutBranch: session.gitBranches.onCheckoutBranch,
-    onBranchMove: session.gitBranches.onBranchMove,
-    layout: () => session.layout,
-    setLayout: (value) => {
-      session.layout = value;
-    },
-    lastFrame: () => session.lastFrame,
-    getSize: () => session.lastSize ?? session.getSize(),
-  });
-};
-
 const bindLifecycle = (session) => {
   session.lifecycle = createLifecycle({
     loader: session.loader,
@@ -329,104 +206,24 @@ const bindLifecycle = (session) => {
       outdatedMap: session.outdatedMap,
       auditMap: session.auditMap,
     },
-    watch: session.watchOpts,
     ui: session,
   });
 };
 
 const bindDispatch = (session) => {
-  const filesPane = session.filesPane;
-  session.dispatcher = createDispatcher({
-    getMode: () => session.mode,
-    getPane: () => session.pane,
-    currentTarget: () => {
-      if (session.pane === 'files') return session.fileCursorEntry();
-      if (session.pane === 'branches') {
-        return session.branches[session.branchCursor];
-      }
-      return session.current();
-    },
-    composer: session.composer,
-    changeActions: session.changeActions,
-    commits: session.commits,
-    gitBranches: session.gitBranches,
-    onFileMove: filesPane.onFileMove,
-    onBranchMove: session.gitBranches.onBranchMove,
-    onNext: filesPane.onNext,
-    onPrev: filesPane.onPrev,
-    onOpenFile: filesPane.onOpenFile,
-    onFiles: filesPane.onFiles,
-    onQuit: () => session.onQuit(),
-    onLayout: filesPane.onLayout,
-    onReload: session.lifecycle.onReload,
-    onScroll: filesPane.onScroll,
-    onHome: filesPane.onHome,
-    onEnd: filesPane.onEnd,
-    scrollStep: filesPane.scrollStep,
-  });
-  session.pointer = createPointer({
-    nav: session.nav,
-    getSize: () => session.lastSize ?? session.getSize(),
-    lastFrame: () => session.lastFrame,
-    copyText: (text, stdout) => session.copyText(text, stdout),
-    stdout: () => session.stdout,
-    setStatus: (value) => {
-      session.status = value;
-    },
-    dispatch: (action) => session.dispatcher.dispatch(action),
-    getPane: () => session.pane,
-    getMode: () => session.mode,
-    confirmChoice: (key) => session.input.confirmChoice(key),
-    onBranch: session.gitBranches.onBranch,
-    onOpenFile: filesPane.onOpenFile,
-    onCheckoutBranch: session.gitBranches.onCheckoutBranch,
-    onTodoHit: (cursor) => session.composer.onTodoHit(cursor),
-    selectTemplate: (index) => session.selectTemplate(index),
-    onScroll: filesPane.onScroll,
-  });
-  session.input = createInput({
-    getMode: () => session.mode,
-    getPane: () => session.pane,
-    composer: session.composer,
-    pointer: session.pointer,
-    dispatch: (action) => session.dispatcher.dispatch(action),
-    onEscape: filesPane.onEscape,
-    onQuit: () => session.onQuit(),
-    runComposeCommand: (result) => session.runComposeCommand(result),
-    quit: {
-      ready: () => session.finishQuit('ready'),
-      editing: () => session.finishQuit('editing'),
-      cancel: () => session.cancelQuit(),
-    },
-    commit: {
-      commit: () => session.commits.startGitCommit('commit'),
-      amend: () => session.commits.startGitCommit('amend'),
-      fixup: () => session.commits.startGitCommit('fixup'),
-      cancel: session.commits.cancelCommit,
-    },
-    update: {
-      accept: session.updater.accept,
-      decline: session.updater.decline,
-    },
-    drop: {
-      confirm: session.gitBranches.confirmDropBranch,
-      cancel: session.gitBranches.cancelDropBranch,
-    },
-    push: {
-      force: session.gitBranches.onForcePush,
-      cancel: session.gitBranches.cancelPush,
-    },
-  });
+  session.dispatcher = createDispatcher(session);
+  session.pointer = createPointer(session);
+  session.input = createInput(session);
 };
 
 const composeSession = (session, options) => {
   assignOptions(session, options);
-  assignUpdater(session);
+  session.updater = createUpdateCoordinator(session);
   assignComposer(session);
   assignControllers(session);
   bindSessionAccessors(session);
   bindViewer(session);
-  bindFilesPane(session);
+  session.filesPane = createFilesPane(session);
   bindLifecycle(session);
   bindDispatch(session);
 };
@@ -444,6 +241,7 @@ class Session {
     if (this.composer) this.composer.reset();
     if (this.ops) this.ops.reset();
     if (this.gitBranches) this.gitBranches.reset();
+    if (this.commits) this.commits.reset();
     this.top = this.cwd;
     this.branch = '';
     this.status = '';
@@ -490,6 +288,10 @@ class Session {
     this.lifecycle.reloadAfterChange(afterLoad);
   }
 
+  ignoreWatch(ms) {
+    this.lifecycle.ignoreWatch(ms);
+  }
+
   applyLoaded(loaded) {
     return this.lifecycle.applyLoaded(loaded);
   }
@@ -507,7 +309,11 @@ class Session {
       height: size.height,
       color: this.color,
     });
-    if (this.pane === 'files' || this.pane === 'branches') {
+    if (
+      this.pane === 'files' ||
+      this.pane === 'branches' ||
+      this.pane === 'commits'
+    ) {
       this.nav.listScroll = frame.listScroll;
     }
     const composing = this.mode === 'compose';
@@ -577,7 +383,7 @@ class Session {
   }
 
   initReview() {
-    this.review.init(this.top, this.now(), {
+    this.review.init(this.top, new Date(), {
       forceNew: this.forceNewReview,
     });
   }
@@ -714,10 +520,7 @@ class Session {
       }
       const onData = (chunk) => {
         this.pushInput(chunk.toString('utf8'));
-        if (this.done) {
-          finish();
-          return;
-        }
+        if (this.done) return void finish();
         this.draw();
       };
       this.term.startListening({

package/lib/source.js

@@ -8,13 +8,13 @@ const selectChangeSource = (paths) => {
   if (!paths.length) return { kind: 'local', paths };
   const first = paths[0];
   const pr = parseGithubPrUrl(first);
-  if (pr) return { kind: 'github-pr', pr, paths: paths.slice(1) };
+  if (pr) return { kind: 'pr', pr, paths: paths.slice(1) };
   const mr = parseGitlabMrUrl(first);
-  if (mr) return { kind: 'gitlab-mr', mr, paths: paths.slice(1) };
+  if (mr) return { kind: 'mr', mr, paths: paths.slice(1) };
   return { kind: 'local', paths };
 };
 
-const createLoadedSource = (loaded, kind = 'github-pr', extra = {}) => {
+const createLoadedSource = (loaded, kind = 'pr', extra = {}) => {
   const load = () => {
     const items = loaded.items ?? [];
     return { ...loaded, items: [...items] };

package/lib/update.js

@@ -1,11 +1,18 @@
 'use strict';
 
-const { spawn } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-const { npmBin, npmOpts } = require('./sys.js');
+const { jsonParse, isHashObject } = require('metautil');
+const {
+  parseVersion,
+  cmpVersion,
+  npmBin,
+  npmOpts,
+  runProc,
+  oneLine,
+} = require('./utilities.js');
 
 const PKG = require('../package.json');
 
@@ -29,45 +36,28 @@ const asText = (value) => (typeof value === 'string' ? value : '');
 
 const toInt = (text) => parseInt(text, 10);
 
-const parseVersion = (text) => {
-  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(`${text ?? ''}`);
-  if (!match) return null;
-  return {
-    major: toInt(match[1]),
-    minor: toInt(match[2]),
-    patch: toInt(match[3]),
-  };
-};
-
-const cmpVersion = (left, right) => {
-  if (left.major !== right.major) return left.major - right.major;
-  if (left.minor !== right.minor) return left.minor - right.minor;
-  return left.patch - right.patch;
-};
-
 const isNpmInstall = (pkgDir) => {
   const parent = path.basename(path.dirname(pkgDir));
   return parent === 'node_modules';
 };
 
-const cacheFile = (env = process.env, extra = {}) => {
-  const home = extra.home ?? os.homedir();
-  const platform = extra.platform ?? process.platform;
+const cacheFile = (env = process.env) => {
   if (env.XDG_CACHE_HOME) {
     return path.join(env.XDG_CACHE_HOME, 'reslop', 'update.json');
   }
-  if (platform === 'win32') {
-    const local = env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+  if (process.platform === 'win32') {
+    const local =
+      env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
     return path.join(local, 'reslop', 'update.json');
   }
-  return path.join(home, '.cache', 'reslop', 'update.json');
+  return path.join(os.homedir(), '.cache', 'reslop', 'update.json');
 };
 
-const readCache = (file, readFileSync = fs.readFileSync) => {
+const readCache = (file) => {
   try {
-    const text = readFileSync(file, 'utf8');
-    const data = JSON.parse(text);
-    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    const text = fs.readFileSync(file, 'utf8');
+    const data = jsonParse(text);
+    if (!isHashObject(data)) {
       return emptyCache();
     }
     const checkedAt = toInt(data.checkedAt) || 0;
@@ -80,17 +70,15 @@ const readCache = (file, readFileSync = fs.readFileSync) => {
   }
 };
 
-const writeCache = (file, data, extra = {}) => {
-  const mkdirSync = extra.mkdirSync ?? fs.mkdirSync;
-  const writeFileSync = extra.writeFileSync ?? fs.writeFileSync;
+const writeCache = (file, data) => {
   try {
-    mkdirSync(path.dirname(file), { recursive: true });
+    fs.mkdirSync(path.dirname(file), { recursive: true });
     const checkedAt = data.checkedAt ?? 0;
     const compatible = data.compatible ?? '';
     const major = data.major ?? '';
     const skipped = data.skipped ?? '';
     const body = JSON.stringify({ checkedAt, compatible, major, skipped });
-    writeFileSync(file, `${body}\n`);
+    fs.writeFileSync(file, `${body}\n`);
   } catch {
     // ignore cache write errors
   }
@@ -106,7 +94,7 @@ const listVersions = (data) => {
   if (!data || typeof data !== 'object') return [];
   const names = [];
   const map = data.versions;
-  if (map && typeof map === 'object' && !Array.isArray(map)) {
+  if (isHashObject(map)) {
     for (const name of Object.keys(map)) names.push(name);
   }
   const tags = data['dist-tags'];
@@ -187,12 +175,6 @@ const isEnabled = (options = {}) => {
   return isNpmInstall(pkgDir);
 };
 
-const nowMs = (options = {}) => {
-  if (typeof options.now === 'function') return options.now();
-  if (typeof options.now === 'number') return options.now;
-  return Date.now();
-};
-
 const fetchTargets = async (current, options = {}) => {
   const empty = { compatible: '', major: '' };
   const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -207,33 +189,18 @@ const fetchTargets = async (current, options = {}) => {
   return pickTargets(current, listVersions(data));
 };
 
-const npmInstall = (spec, extra = {}) =>
-  new Promise((resolve, reject) => {
-    const stdio = ['ignore', 'ignore', 'pipe'];
-    const child = spawn(npmBin(), ['install', '-g', spec], npmOpts({ stdio }));
-    let stderr = '';
-    if (child.stderr) {
-      child.stderr.setEncoding('utf8');
-      child.stderr.on('data', (chunk) => {
-        stderr += chunk;
-      });
-    }
-    const timeout = extra.timeout ?? INSTALL_MS;
-    const timer = setTimeout(() => {
-      child.kill();
-      reject(new Error('timed out'));
-    }, timeout);
-    child.on('error', (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-    child.on('close', (status) => {
-      clearTimeout(timer);
-      if (status === 0) return void resolve();
-      const line = stderr.trim().split('\n')[0];
-      reject(new Error(line || 'npm install failed'));
-    });
-  });
+const npmInstall = async (spec, extra = {}) => {
+  const timeout = extra.timeout ?? INSTALL_MS;
+  const result = await runProc(
+    npmBin(),
+    ['install', '-g', spec],
+    npmOpts({ timeout }),
+  );
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(oneLine(result.stderr, 'npm install failed'));
+  }
+};
 
 const installUpdate = async (version, options = {}) => {
   if (typeof options.install === 'function') {
@@ -246,19 +213,17 @@ const installUpdate = async (version, options = {}) => {
 
 const markSkipped = (version, options = {}) => {
   const file = options.cacheFile ?? cacheFile(options.env);
-  const readFileSync = options.readFileSync ?? fs.readFileSync;
-  const cache = readCache(file, readFileSync);
-  writeCache(file, { ...cache, skipped: version }, options);
+  const cache = readCache(file);
+  writeCache(file, { ...cache, skipped: version });
 };
 
 const checkUpdate = async (options = {}) => {
   if (!isEnabled(options)) return { action: 'skip' };
-  const now = nowMs(options);
+  const now = Date.now();
   const current = options.current ?? PKG_VERSION;
   const file = options.cacheFile ?? cacheFile(options.env);
-  const readFileSync = options.readFileSync ?? fs.readFileSync;
   const interval = options.interval ?? CHECK_INTERVAL_MS;
-  const cache = readCache(file, readFileSync);
+  const cache = readCache(file);
   if (isFresh(cache, now, interval)) {
     const plan = planUpdate(current, cache);
     if (plan.action === 'install') return { action: 'none' };
@@ -277,10 +242,10 @@ const checkUpdate = async (options = {}) => {
     major: targets.major,
   };
   if (!targets.compatible && !targets.major) {
-    writeCache(file, { ...cache, checkedAt: now }, options);
+    writeCache(file, { ...cache, checkedAt: now });
     return { action: 'none' };
   }
-  writeCache(file, next, options);
+  writeCache(file, next);
   return planUpdate(current, next);
 };