reslop 0.2.4 → 0.2.6

package/lib/session/ops.js

@@ -1,48 +1,184 @@
 '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`];
   const allowAsync = uiOpen === true || ASYNC_WITHOUT_UI.includes(name);
-  if (allowAsync && typeof asyncFn === 'function') {
-    return {
-      async: true,
-      write: (top, ...args) => asyncFn(top, ...args),
-    };
-  }
-  const syncFn = repo[name];
-  return {
-    async: false,
-    write: (top, ...args) => syncFn(top, ...args),
-  };
+  const isAsync = allowAsync && typeof asyncFn === 'function';
+  return { async: isAsync, write: isAsync ? asyncFn : repo[name] };
 };
 
-const createOpsRunner = (ui) => {
-  const state = {
-    gitBusy: false,
-    busy: '',
-  };
+const showsBusy = (kind) => Boolean(kind) && !QUIET_KIND.has(kind);
+
+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;
+  }
+
+  noteFree() {
+    const resume = this.resume;
+    this.resume = null;
+    if (resume) resume();
+  }
+
+  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;
+    });
+  }
+
+  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;
+    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);
+  }
 
-  const reset = () => {
-    state.gitBusy = false;
-    state.busy = '';
-  };
+  setBusy(kind) {
+    this.busy = kind;
+    this.ui.startProgress();
+  }
 
-  const setBusy = (kind) => {
-    state.busy = kind;
-    ui.startProgress();
-  };
+  clearBusy() {
+    this.busy = '';
+    this.ui.stopProgress();
+  }
 
-  const clearBusy = () => {
-    state.busy = '';
-    ui.stopProgress();
-  };
+  reset() {
+    this.gitBusy = false;
+    this.busy = '';
+    this.queue.reset();
+  }
 
-  const runRepo = (label, write) => {
+  runRepo(label, write) {
+    const { ui } = this;
     try {
       write(ui.top);
       ui.status = label;
@@ -51,21 +187,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 +214,31 @@ 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, leave = null) {
+    const { ui } = this;
     const picked = pickRepoWrite(ui.repo, name, ui.uiOpen);
     const write = (top) => picked.write(top, ...args);
     if (picked.async) {
+      if (leave) leave();
       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;
+    if (leave) leave();
     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 };

package/lib/session/pointer.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const select = require('../select.js');
+const editClick = require('./edit-click.js');
+const filesPane = require('./files-pane.js');
 const { extractText, isRange } = select;
 const keys = require('../keys.js');
 const { hitAction } = keys;
@@ -93,23 +95,30 @@ const RELEASE_TARGETS = [
     hits: 'statusHits',
     onHit: (ui, hit) => {
       if (hit.id === 'branch') return void ui.gitBranches.onBranch();
-      ui.input.confirmChoice(hit.id);
+      ui.confirmChoice(hit.id);
     },
   },
+  {
+    match: (ui) => ui.pane === 'dashboard',
+    hits: 'fileHits',
+    onHit: (ui, hit) => ui.dashboard.open(hit.cursor),
+  },
   {
     match: (ui) => ui.pane === 'files',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      const again = armDoubleClick(ui.nav, 'files', hit.cursor);
       ui.nav.fileCursor = hit.cursor;
-      ui.filesPane.onOpenFile();
+      if (again) filesPane.onOpenFile(ui);
     },
   },
   {
     match: (ui) => ui.pane === 'branches',
     hits: 'fileHits',
     onHit: (ui, hit) => {
+      const again = armDoubleClick(ui.nav, 'branches', hit.cursor);
       ui.nav.branchCursor = hit.cursor;
-      ui.gitBranches.onCheckoutBranch();
+      if (again) ui.gitBranches.onCheckoutBranch();
     },
   },
   {
@@ -117,7 +126,9 @@ const RELEASE_TARGETS = [
     hits: 'fileHits',
     onHit: (ui, hit) => {
       if (ui.mode === 'compose') return;
+      const again = armDoubleClick(ui.nav, 'commits', hit.cursor);
       ui.nav.commitCursor = hit.cursor;
+      if (again) filesPane.onOpenFile(ui);
     },
   },
   {
@@ -130,11 +141,11 @@ const RELEASE_TARGETS = [
     },
   },
   {
-    match: (ui) => ui.pane === 'diff',
-    hits: 'todoHits',
+    match: (ui) => ui.pane === 'tasks',
+    hits: 'taskHits',
     onHit: (ui, hit) => {
-      if (hit.check) return void ui.composer.onTodoCheck(hit.cursor);
-      ui.composer.onTodoHit(hit.cursor);
+      if (hit.check) return void ui.composer.tasks.onTaskCheck(hit.cursor);
+      ui.composer.tasks.onTaskHit(hit.cursor);
     },
   },
   {
@@ -154,6 +165,7 @@ const onRelease = (ui, event) => {
   nav.pendingClick = null;
   nav.mouseAnchor = null;
   if (clickButton(ui, cell, clickId)) return;
+  if (editClick.placeClick(ui, cell)) return;
   const frame = ui.lastFrame;
   for (const target of RELEASE_TARGETS) {
     if (!target.match(ui)) continue;
@@ -165,14 +177,14 @@ const onRelease = (ui, event) => {
 };
 
 const POINTER_HANDLERS = {
-  wheelUp: (ui) => ui.filesPane.onScroll(-1),
-  wheelDown: (ui) => ui.filesPane.onScroll(1),
+  wheelUp: (ui) => filesPane.onScroll(ui, -1),
+  wheelDown: (ui) => filesPane.onScroll(ui, 1),
   press: onPress,
   drag: onDrag,
   release: onRelease,
 };
 
-const handle = (ui, event) => {
+const handlePointer = (ui, event) => {
   const kind = event.kind;
   const handler = POINTER_HANDLERS[kind];
   if (!handler) return;
@@ -181,8 +193,4 @@ const handle = (ui, event) => {
   handler(ui, event);
 };
 
-const createPointer = (ui) => ({
-  handle: (event) => handle(ui, event),
-});
-
-module.exports = { createPointer };
+module.exports = { handlePointer };

package/lib/session/progress.js

@@ -1,29 +1,41 @@
 'use strict';
 
-const createProgress = (term, onTick, intervalMs) => {
-  const active = new Set();
+class Progress {
+  constructor(term, onTick, intervalMs) {
+    this.term = term;
+    this.onTick = onTick;
+    this.intervalMs = intervalMs;
+    this.active = new Set();
+  }
 
-  const start = (id) => {
-    const wasEmpty = active.size === 0;
-    active.add(id);
-    if (wasEmpty) {
-      term.startTimer('progress', onTick, intervalMs);
-    }
-  };
+  tick() {
+    if (!this.active.size) return;
+    this.onTick();
+    this.schedule();
+  }
 
-  const stop = (id) => {
-    active.delete(id);
-    if (active.size === 0) term.stopTimer('progress');
-  };
+  schedule() {
+    this.term.later('progress', () => this.tick(), this.intervalMs);
+  }
 
-  const clear = () => {
-    active.clear();
-    term.stopTimer('progress');
-  };
+  start(id) {
+    this.active.add(id);
+    this.schedule();
+  }
 
-  const size = () => active.size;
+  stop(id) {
+    this.active.delete(id);
+    if (!this.active.size) this.term.cancel('progress');
+  }
 
-  return { start, stop, clear, size };
-};
+  clear() {
+    this.active.clear();
+    this.term.cancel('progress');
+  }
 
-module.exports = { createProgress };
+  size() {
+    return this.active.size;
+  }
+}
+
+module.exports = { Progress };

package/lib/session/review.js

@@ -1,75 +1,54 @@
 'use strict';
 
-const accessors = require('./accessors.js');
-const { stateView } = accessors;
-
 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,
-    importedRemote: false,
-  };
+class ReviewController {
+  constructor() {
+    this.reset();
+  }
 
-  const reset = () => {
-    state.store = null;
-    state.didResume = false;
-    state.importedRemote = false;
-  };
+  reset() {
+    this.store = null;
+    this.didResume = false;
+    this.importedRemote = false;
+  }
 
-  const init = (dir, date, extra = {}) => {
+  init(dir, date, extra = {}) {
     const names = listReviewNames(dir);
     const templates = loadTemplates(dir);
     const resolved = resolveReviewPath(dir, date, names, extra);
-    if (resolved.resume) {
-      state.store = loadReview(resolved.reviewPath, templates);
-      state.didResume = true;
-      return state.store;
-    }
-    state.store = createStore(resolved.reviewPath, templates);
-    state.didResume = false;
-    return state.store;
-  };
-
-  const applyImported = (imported) => {
-    if (!imported || !state.store) return false;
-    if (state.didResume || state.importedRemote) return false;
-    applyImportedNotes(state.store, imported);
-    state.importedRemote = true;
+    this.didResume = resolved.resume === true;
+    this.store = this.didResume
+      ? loadReview(resolved.reviewPath, templates)
+      : createStore(resolved.reviewPath, templates);
+    return this.store;
+  }
+
+  applyImported(imported) {
+    if (!imported || !this.store) return false;
+    if (this.didResume || this.importedRemote) return false;
+    applyImportedNotes(this.store, imported);
+    this.importedRemote = true;
     return true;
-  };
+  }
 
-  const flush = (force = false) => {
-    if (!state.store) return { ok: true, wrote: false };
+  flush(force = false) {
+    if (!this.store) return { ok: true, wrote: false };
     try {
-      const wrote = flushReview(state.store, force);
+      const wrote = flushReview(this.store, force);
       return { ok: true, wrote };
     } catch (error) {
       return { ok: false, wrote: false, error };
     }
-  };
-
-  const finishQuit = (status) => {
-    setStatus(state.store, status);
-    return flush();
-  };
+  }
 
-  return stateView(
-    state,
-    {
-      reset,
-      init,
-      applyImported,
-      flush,
-      finishQuit,
-    },
-    [],
-    ['store', 'didResume', 'importedRemote'],
-  );
-};
+  finishQuit(status) {
+    setStatus(this.store, status);
+    return this.flush();
+  }
+}
 
-module.exports = { createReviewController };
+module.exports = { ReviewController };