reslop 0.2.4 → 0.2.5

package/lib/session/npm.js

@@ -4,9 +4,11 @@ const commands = require('../npm-commands.js');
 const npm = require('../render/npm.js');
 const { logViewRows } = npm;
 
-const { listCommands, reduceOutput, writeLog, parseScriptLine } = commands;
+const { listCommands, reduceOutput, writeLog } = commands;
 const { staleLogFiles, removeStaleLogs, formatSize } = commands;
-const { scriptLine, saveScript, removeScript, reorderScript } = commands;
+const { saveScript, removeScript, reorderScript } = commands;
+
+const NAME_RE = /^[\w:.-]+$/;
 const { startNpm } = commands;
 
 const selected = (api) => {
@@ -48,9 +50,11 @@ const open = (api) => {
   refreshLogs(api);
   api.state.viewing = false;
   api.state.output = '';
-  api.ui.nav.pane = 'npm';
+  const nav = api.ui.nav;
+  nav.pane = 'npm';
+  nav.resetListScroll('npm');
   api.ui.status = '';
-  api.ui.nav.clearSelection();
+  nav.clearSelection();
 };
 
 const scrollLog = (api, delta) => {
@@ -80,13 +84,22 @@ const move = (api, delta) => {
 const stopRun = (api) => {
   api.state.running = false;
   api.state.child = null;
-  if (api.ui.progress) api.ui.progress.stop('npm');
+  api.ui.progress.stop('npm');
+};
+
+const shownOutput = (api, raw, status) => {
+  if (!api.state.verbose) return reduceOutput(raw, api.ui.top, status);
+  const text = `${raw ?? ''}`;
+  if (!text) return '';
+  if (text.endsWith('\n')) return text;
+  return `${text}\n`;
 };
 
 const showOutput = (api, text) => {
   if (!api.state.viewing || !api.state.running) return;
   if (api.state.stopping) return;
-  api.state.output = text;
+  api.state.raw = text;
+  api.state.output = shownOutput(api, text, '');
   api.ui.paint();
 };
 
@@ -100,10 +113,13 @@ const withNotice = (text, notice) => {
 
 const finishRun = (api, entry, result) => {
   const stopped = api.state.stopping === true;
+  const raw = stopped ? withNotice(api.state.raw, 'terminated') : result.text;
   const reduced = stopped
-    ? withNotice(api.state.output, 'terminated')
+    ? withNotice(reduceOutput(api.state.raw, api.ui.top, ''), 'terminated')
     : reduceOutput(result.text, api.ui.top, result.status);
-  api.state.output = reduced;
+  api.state.raw = raw;
+  api.state.exitStatus = stopped ? '' : result.status;
+  api.state.output = api.state.verbose ? shownOutput(api, raw, '') : reduced;
   api.state.stopping = false;
   stopRun(api);
   try {
@@ -119,21 +135,24 @@ const finishRun = (api, entry, result) => {
 
 const startRun = (api, entry) => {
   api.state.output = '';
+  api.state.raw = '';
+  api.state.exitStatus = '';
   api.state.viewing = true;
   api.state.followEnd = true;
   api.state.logScroll = 0;
   api.state.running = true;
   api.state.stopping = false;
   api.ui.status = '';
-  if (api.ui.progress) api.ui.progress.start('npm');
+  api.ui.progress.start('npm');
   const runner = api.ui.repo && api.ui.repo.runNpmCommand;
   const start = typeof runner === 'function' ? runner : startNpm;
-  api.state.child = start(
+  const child = start(
     api.ui.top,
     entry,
-    (text) => showOutput(api, reduceOutput(text, api.ui.top, '')),
+    (text) => showOutput(api, text),
     (result) => finishRun(api, entry, result),
   );
+  if (api.state.running) api.state.child = child;
   api.ui.paint();
 };
 
@@ -141,6 +160,7 @@ const runSelected = (api) => {
   if (api.state.viewing || api.state.child) return;
   const entry = selected(api);
   if (!entry) return;
+  api.state.verbose = false;
   startRun(api, entry);
 };
 
@@ -156,50 +176,106 @@ const closeView = (api) => {
     api.state.stopping = true;
     if (api.state.child) api.state.child.kill();
     if (!api.state.running) return;
-    api.state.output = withNotice(api.state.output, 'terminated');
+    api.state.raw = withNotice(api.state.raw, 'terminated');
+    api.state.output = api.state.verbose
+      ? shownOutput(api, api.state.raw, '')
+      : withNotice(api.state.output, 'terminated');
     stopRun(api);
     api.ui.status = 'terminated';
     api.ui.paint();
     return;
   }
   api.state.viewing = false;
+  api.state.verbose = false;
   api.ui.status = '';
   api.ui.paint();
 };
 
-const editSelected = (api) => {
-  if (api.state.viewing) return;
-  if (!canEdit(api.ui)) {
-    api.ui.status = 'read only';
-    return;
-  }
+const toggleVerbose = (api) => {
+  if (!api.state.viewing) return;
+  api.state.verbose = !api.state.verbose;
+  const status = api.state.running ? '' : api.state.exitStatus;
+  api.state.output = shownOutput(api, api.state.raw, status);
+  api.ui.status = api.state.verbose ? 'verbose' : 'filtered';
+  api.ui.paint();
+};
+
+const editable = (api) => {
+  if (api.state.viewing) return false;
+  if (canEdit(api.ui)) return true;
+  api.ui.status = 'read only';
+  return false;
+};
+
+const selectedScript = (api) => {
+  if (!editable(api)) return null;
   const entry = selected(api);
-  if (!entry || entry.kind !== 'script') {
-    api.ui.status = 'not a script';
-    return;
-  }
+  if (entry && entry.kind === 'script') return entry;
+  api.ui.status = 'not a script';
+  return null;
+};
+
+const focusScript = (api, name) => {
+  const at = api.state.commands.findIndex((entry) => entry.name === name);
+  if (at >= 0) api.ui.nav.npmCursor = at;
+};
+
+const editSelected = (api) => {
+  const entry = selectedScript(api);
+  if (!entry) return;
   api.state.editName = entry.name;
-  api.ui.composer.openCompose('npm', scriptLine(entry));
+  api.state.editField = 'name';
+  api.state.draftName = entry.name;
+  api.state.draftCommand = entry.command ?? '';
+  api.ui.composer.openCompose('npm', entry.name);
 };
 
 const newCommand = (api) => {
-  if (api.state.viewing) return;
-  if (!canEdit(api.ui)) {
-    api.ui.status = 'read only';
-    return;
-  }
+  if (!editable(api)) return;
   api.state.editName = '';
+  api.state.editField = 'name';
+  api.state.draftName = '';
+  api.state.draftCommand = '';
   api.ui.composer.openCompose('npm', '');
 };
 
+const switchField = (api, editor, field, text) => {
+  api.state.editField = field;
+  editor.replace(text);
+  api.ui.status = '';
+};
+
+const finishName = (api, editor) => {
+  const name = editor.text.trim();
+  if (!name || !NAME_RE.test(name)) {
+    api.ui.status = 'name';
+    return false;
+  }
+  api.state.draftName = name;
+  switchField(api, editor, 'command', api.state.draftCommand);
+  return true;
+};
+
+const focusField = (api, field) => {
+  const editor = api.ui.editor;
+  if (!editor) return false;
+  if (field === api.state.editField) return true;
+  if (field === 'command') return finishName(api, editor);
+  api.state.draftCommand = editor.text;
+  switchField(api, editor, 'name', api.state.draftName ?? '');
+  return true;
+};
+
 const finishEdit = (api) => {
   const editor = api.ui.composer.state.editor;
-  const text = editor ? editor.text : '';
-  const parsed = parseScriptLine(text);
-  if (!parsed) {
-    api.ui.status = 'name: command';
+  if (!editor) return;
+  if (api.state.editField !== 'command') return void finishName(api, editor);
+  const command = editor.text.trim();
+  if (!command) {
+    api.ui.status = 'command';
     return;
   }
+  const parsed = { name: api.state.draftName, command };
   try {
     api.ui.ignoreWatch();
     saveScript(api.ui.top, api.state.editName, parsed);
@@ -207,26 +283,16 @@ const finishEdit = (api) => {
     api.ui.status = error.message;
     return;
   }
+  api.state.editField = '';
   api.ui.composer.closeCompose();
   refresh(api);
-  const at = api.state.commands.findIndex(
-    (entry) => entry.name === parsed.name,
-  );
-  if (at >= 0) api.ui.nav.npmCursor = at;
+  focusScript(api, parsed.name);
   api.ui.status = 'saved';
 };
 
 const askDrop = (api) => {
-  if (api.state.viewing) return;
-  if (!canEdit(api.ui)) {
-    api.ui.status = 'read only';
-    return;
-  }
-  const entry = selected(api);
-  if (!entry || entry.kind !== 'script') {
-    api.ui.status = 'not a script';
-    return;
-  }
+  const entry = selectedScript(api);
+  if (!entry) return;
   api.state.dropKind = 'script';
   api.state.dropName = entry.name;
   api.ui.mode = 'confirmDrop';
@@ -234,11 +300,7 @@ const askDrop = (api) => {
 };
 
 const askLogs = (api) => {
-  if (api.state.viewing) return;
-  if (!canEdit(api.ui)) {
-    api.ui.status = 'read only';
-    return;
-  }
+  if (!editable(api)) return;
   refreshLogs(api);
   if (!api.state.logBytes) return;
   api.state.dropKind = 'logs';
@@ -286,16 +348,8 @@ const cancelDrop = (api) => {
 };
 
 const reorder = (api, delta) => {
-  if (api.state.viewing) return;
-  if (!canEdit(api.ui)) {
-    api.ui.status = 'read only';
-    return;
-  }
-  const entry = selected(api);
-  if (!entry || entry.kind !== 'script') {
-    api.ui.status = 'not a script';
-    return;
-  }
+  const entry = selectedScript(api);
+  if (!entry) return;
   try {
     api.ui.ignoreWatch();
     if (!reorderScript(api.ui.top, entry.name, delta)) return;
@@ -304,26 +358,33 @@ const reorder = (api, delta) => {
     return;
   }
   refresh(api);
-  const at = api.state.commands.findIndex((item) => item.name === entry.name);
-  if (at >= 0) api.ui.nav.npmCursor = at;
+  focusScript(api, entry.name);
   api.ui.status = '';
 };
 
+const npmState = () => ({
+  commands: [],
+  viewing: false,
+  output: '',
+  followEnd: true,
+  logScroll: 0,
+  editName: '',
+  editField: '',
+  draftName: '',
+  draftCommand: '',
+  verbose: false,
+  raw: '',
+  exitStatus: '',
+  dropName: '',
+  dropKind: '',
+  logBytes: 0,
+  running: false,
+  stopping: false,
+  child: null,
+});
+
 const createNpmController = (ui) => {
-  const state = {
-    commands: [],
-    viewing: false,
-    output: '',
-    followEnd: true,
-    logScroll: 0,
-    editName: '',
-    dropName: '',
-    dropKind: '',
-    logBytes: 0,
-    running: false,
-    stopping: false,
-    child: null,
-  };
+  const state = npmState();
   const api = { ui, state };
   return {
     state,
@@ -352,6 +413,18 @@ const createNpmController = (ui) => {
     get editName() {
       return state.editName;
     },
+    get editField() {
+      return state.editField;
+    },
+    get draftName() {
+      return state.draftName;
+    },
+    get draftCommand() {
+      return state.draftCommand;
+    },
+    get verbose() {
+      return state.verbose;
+    },
     get running() {
       return state.running;
     },
@@ -364,6 +437,12 @@ const createNpmController = (ui) => {
       state.followEnd = true;
       state.logScroll = 0;
       state.editName = '';
+      state.editField = '';
+      state.draftName = '';
+      state.draftCommand = '';
+      state.verbose = false;
+      state.raw = '';
+      state.exitStatus = '';
       state.dropName = '';
       state.dropKind = '';
       state.logBytes = 0;
@@ -374,9 +453,11 @@ const createNpmController = (ui) => {
     run: () => runSelected(api),
     rerun: () => rerun(api),
     closeView: () => closeView(api),
+    toggleVerbose: () => toggleVerbose(api),
     edit: () => editSelected(api),
     create: () => newCommand(api),
     finishEdit: () => finishEdit(api),
+    focusField: (field) => focusField(api, field),
     askDrop: () => askDrop(api),
     askLogs: () => askLogs(api),
     confirmDrop: () => confirmDrop(api),

package/lib/session/ops.js

@@ -1,9 +1,7 @@
 'use strict';
 
-const accessors = require('./accessors.js');
-const { stateView } = accessors;
-
 const ASYNC_WITHOUT_UI = ['pull', 'push'];
+const QUIET_KIND = new Set(['staged', 'unstaged']);
 
 const pickRepoWrite = (repo, name, uiOpen) => {
   const asyncFn = repo[`${name}Async`];
@@ -21,28 +19,176 @@ const pickRepoWrite = (repo, name, uiOpen) => {
   };
 };
 
-const createOpsRunner = (ui) => {
-  const state = {
-    gitBusy: false,
-    busy: '',
-  };
+const showsBusy = (kind) => Boolean(kind) && !QUIET_KIND.has(kind);
 
-  const reset = () => {
-    state.gitBusy = false;
-    state.busy = '';
-  };
+class ChangeQueue {
+  constructor(ui, runner) {
+    this.ui = ui;
+    this.runner = runner;
+    this.jobs = [];
+    this.head = 0;
+    this.epoch = 0;
+    this.draining = false;
+    this.pumpQueued = false;
+    this.holding = false;
+    this.resume = null;
+    this.reloading = false;
+  }
 
-  const setBusy = (kind) => {
-    state.busy = kind;
-    ui.startProgress();
-  };
+  noteFree() {
+    const resume = this.resume;
+    this.resume = null;
+    if (resume) resume();
+  }
 
-  const clearBusy = () => {
-    state.busy = '';
-    ui.stopProgress();
-  };
+  dropJobs() {
+    this.jobs = [];
+    this.head = 0;
+  }
+
+  reset() {
+    this.epoch += 1;
+    this.dropJobs();
+    this.draining = false;
+    this.pumpQueued = false;
+    this.holding = false;
+    this.reloading = false;
+    this.noteFree();
+  }
+
+  armBusy(kind) {
+    if (!showsBusy(kind)) return;
+    this.ui.status = '';
+    this.ui.progressFrame = 0;
+    this.runner.setBusy(kind);
+  }
+
+  waitTurn() {
+    if (!this.runner.gitBusy || this.holding) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.resume = resolve;
+    });
+  }
 
-  const runRepo = (label, write) => {
+  hasPendingBusy() {
+    const { jobs, head } = this;
+    for (let i = head; i < jobs.length; i++) {
+      if (showsBusy(jobs[i].kind)) return true;
+    }
+    return false;
+  }
+
+  releaseHold() {
+    this.holding = false;
+    this.runner.gitBusy = false;
+    this.noteFree();
+  }
+
+  startReload() {
+    const { ui } = this;
+    if (typeof ui.reloadAfterChange !== 'function') return void ui.paint();
+    this.reloading = true;
+    ui.reloadAfterChange(() => {
+      this.reloading = false;
+      ui.paint();
+    });
+  }
+
+  async takeJob(stamp) {
+    const job = this.jobs[this.head];
+    this.head += 1;
+    this.armBusy(job.kind);
+    try {
+      await job.write(this.ui.top);
+    } catch (error) {
+      if (stamp !== this.epoch) return 'stale';
+      this.ui.status = error.message;
+      return 'fail';
+    }
+    if (stamp !== this.epoch) return 'stale';
+    if (job.done) this.ui.status = job.done;
+    if (!this.hasPendingBusy()) this.runner.clearBusy();
+    return job.reload ? 'reload' : 'ok';
+  }
+
+  schedule() {
+    if (this.draining || this.pumpQueued) return;
+    this.pumpQueued = true;
+    queueMicrotask(() => {
+      this.pumpQueued = false;
+      void this.run();
+    });
+  }
+
+  finish(stamp, needReload) {
+    if (stamp !== this.epoch) return;
+    this.draining = false;
+    this.releaseHold();
+    if (this.head < this.jobs.length) return void this.schedule();
+    this.dropJobs();
+    if (needReload) this.startReload();
+    else this.ui.paint();
+  }
+
+  async run() {
+    const stamp = this.epoch;
+    this.draining = true;
+    if (this.runner.gitBusy && !this.holding) await this.waitTurn();
+    if (stamp !== this.epoch) return;
+    this.holding = true;
+    this.runner.gitBusy = true;
+    let needReload = false;
+    while (this.head < this.jobs.length) {
+      const result = await this.takeJob(stamp);
+      if (result === 'stale') return;
+      if (result === 'fail') {
+        needReload = true;
+        this.dropJobs();
+        break;
+      }
+      if (result === 'reload') needReload = true;
+    }
+    this.finish(stamp, needReload);
+  }
+
+  enqueue(job) {
+    if (this.reloading) {
+      this.ui.loader.bump();
+      this.reloading = false;
+      job.reload = true;
+    }
+    this.jobs.push(job);
+    this.armBusy(job.kind);
+    this.schedule();
+  }
+}
+
+class OpsRunner {
+  constructor(ui) {
+    this.ui = ui;
+    this.gitBusy = false;
+    this.busy = '';
+    this.queue = new ChangeQueue(ui, this);
+  }
+
+  setBusy(kind) {
+    this.busy = kind;
+    this.ui.startProgress();
+  }
+
+  clearBusy() {
+    this.busy = '';
+    this.ui.stopProgress();
+  }
+
+  reset() {
+    this.gitBusy = false;
+    this.busy = '';
+    this.queue.reset();
+  }
+
+  runRepo(label, write) {
+    const { ui } = this;
     try {
       write(ui.top);
       ui.status = label;
@@ -51,21 +197,23 @@ const createOpsRunner = (ui) => {
       ui.status = error.message;
       return false;
     }
-  };
+  }
 
-  const finishBusy = (done, after) => {
+  finishBusy(done, after) {
+    const { ui } = this;
     if (ui.done || ui.mode === 'confirmPush') return void ui.paint();
     if (!ui.status && after) after();
-    if (!ui.status && !state.busy) ui.status = done;
+    if (!ui.status && !this.busy) ui.status = done;
     ui.paint();
-  };
+  }
 
-  const runBusy = async (kind, done, write, after) => {
-    if (state.gitBusy) return;
-    state.gitBusy = true;
+  async runBusy(kind, done, write, after) {
+    const { ui } = this;
+    if (this.gitBusy) return;
+    this.gitBusy = true;
     ui.status = '';
     ui.progressFrame = 0;
-    setBusy(kind);
+    this.setBusy(kind);
     ui.paint();
     try {
       await write(ui.top);
@@ -76,36 +224,29 @@ const createOpsRunner = (ui) => {
         ui.status = error.message;
       }
     } finally {
-      clearBusy();
-      state.gitBusy = false;
+      this.clearBusy();
+      this.gitBusy = false;
+      this.queue.noteFree();
     }
-    finishBusy(done, after);
-  };
+    this.finishBusy(done, after);
+  }
 
-  const runWrite = (name, args, kind, done, after) => {
+  runWrite(name, args, kind, done, after) {
+    const { ui } = this;
     const picked = pickRepoWrite(ui.repo, name, ui.uiOpen);
     const write = (top) => picked.write(top, ...args);
     if (picked.async) {
       const refresh = () => after({ doneStatus: done });
-      return void runBusy(kind, done, write, refresh);
+      return void this.runBusy(kind, done, write, refresh);
     }
-    if (!runRepo(done, write)) return;
+    if (!this.runRepo(done, write)) return;
     after({});
     if (!ui.status) ui.status = done;
-  };
+  }
 
-  return stateView(
-    state,
-    {
-      reset,
-      setBusy,
-      clearBusy,
-      runRepo,
-      runWrite,
-      runBusy,
-    },
-    ['gitBusy', 'busy'],
-  );
-};
+  enqueueLazy(job) {
+    this.queue.enqueue(job);
+  }
+}
 
-module.exports = { ASYNC_WITHOUT_UI, pickRepoWrite, createOpsRunner };
+module.exports = { pickRepoWrite, OpsRunner };