reslop 0.1.9 → 0.2.1

package/lib/session/branches.js

@@ -1,261 +1,257 @@
 'use strict';
 
+const { stateView } = require('./accessors.js');
+
 const { pickRepoWrite } = require('./ops.js');
 
 const selectedBranch = (api) => {
-  const cursor = api.options.nav.branchCursor;
+  const cursor = api.ui.nav.branchCursor;
   return api.state.branches[cursor];
 };
 
 const refreshBranchList = (api) => {
-  const repo = api.options.repo();
+  const repo = api.ui.repo;
   if (!repo.listBranches) return;
   try {
-    api.state.branches = repo.listBranches(api.options.top());
+    api.state.branches = repo.listBranches(api.ui.top);
   } catch (error) {
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   const last = api.state.branches.length - 1;
-  const nav = api.options.nav;
+  const nav = api.ui.nav;
   if (nav.branchCursor > last) nav.branchCursor = Math.max(0, last);
 };
 
 const refreshAfterWrite = (api, extra = {}) => {
   refreshBranchList(api);
-  api.options.refreshFromRepo({ keepEmpty: true, ...extra });
+  api.ui.commits.refresh();
+  api.ui.refreshFromRepo({ keepEmpty: true, ...extra });
 };
 
 const onBranch = (api) => {
-  if (api.options.getMode() === 'compose') return;
-  if (!api.options.canCommit()) return;
-  const repo = api.options.repo();
-  const caps = api.options.capabilities();
+  if (api.ui.mode === 'compose') return;
+  if (!api.ui.commits.canCommit()) return;
+  const repo = api.ui.repo;
+  const caps = api.ui.capabilities;
   if (!caps.branches || !repo.listBranches) {
-    api.options.setStatus('read only');
+    api.ui.status = 'read only';
     return;
   }
   try {
-    api.state.branches = repo.listBranches(api.options.top());
+    api.state.branches = repo.listBranches(api.ui.top);
   } catch (error) {
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   const current = api.state.branches.findIndex((entry) => entry.current);
-  api.options.nav.branchCursor = current < 0 ? 0 : current;
-  api.options.nav.pane = 'branches';
-  api.options.setStatus('');
-  api.options.nav.clearSelection();
+  api.ui.nav.branchCursor = current < 0 ? 0 : current;
+  api.ui.nav.pane = 'branches';
+  api.ui.status = '';
+  api.ui.nav.clearSelection();
 };
 
 const onBranchMove = (api, delta) => {
   const branches = api.state.branches;
   if (!branches.length) {
-    api.options.setStatus('nothing to review');
+    api.ui.status = 'nothing to review';
     return;
   }
   const next = Math.min(
     branches.length - 1,
-    Math.max(0, api.options.nav.branchCursor + delta),
+    Math.max(0, api.ui.nav.branchCursor + delta),
   );
-  if (next === api.options.nav.branchCursor) return;
-  api.options.nav.branchCursor = next;
-  api.options.setStatus('');
+  if (next === api.ui.nav.branchCursor) return;
+  api.ui.nav.branchCursor = next;
+  api.ui.status = '';
 };
 
 const checkoutAsync = (api, name, done, write) => {
-  api.options.showFiles();
+  api.ui.showFiles();
   const run = (top) => write(top, name);
   const after = () =>
-    api.options.refreshFromRepo({ keepEmpty: true, doneStatus: done });
-  return void api.options.runner.runBusy('checking out', done, run, after);
+    api.ui.refreshFromRepo({ keepEmpty: true, doneStatus: done });
+  return void api.ui.ops.runBusy('checking out', done, run, after);
 };
 
 const onCheckoutBranch = (api) => {
-  if (!api.options.canCommit()) return;
+  if (!api.ui.commits.canCommit()) return;
   const entry = selectedBranch(api);
   if (!entry) return;
-  if (entry.current) {
-    api.options.showFiles();
-    return;
-  }
+  if (entry.current) return void api.ui.showFiles();
   const name = entry.name;
   const done = `checked out ${name}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'checkout', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'checkout', uiOpen);
   if (picked.async) {
-    checkoutAsync(api, name, done, picked.write);
-    return;
+    return void checkoutAsync(api, name, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().checkout(top, name);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.checkout(top, name);
   });
   if (!ok) return;
-  api.options.showFiles();
-  api.options.refreshFromRepo({ keepEmpty: true });
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  api.ui.showFiles();
+  api.ui.refreshFromRepo({ keepEmpty: true });
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const rebaseAsync = (api, onto, done, write) => {
   const run = (top) => write(top, onto);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.options.runner.runBusy('rebasing', done, run, after);
+  return void api.ui.ops.runBusy('rebasing', done, run, after);
 };
 
 const onRebaseBranch = (api) => {
-  if (api.options.nav.pane !== 'branches') return;
-  if (!api.options.canCommit()) return;
+  if (api.ui.nav.pane !== 'branches') return;
+  if (!api.ui.commits.canCommit()) return;
   const entry = selectedBranch(api);
   if (!entry || entry.current) return;
   const onto = entry.name;
   const done = `rebased onto ${onto}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'rebase', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'rebase', uiOpen);
   if (picked.async) {
-    rebaseAsync(api, onto, done, picked.write);
-    return;
+    return void rebaseAsync(api, onto, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().rebase(top, onto);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.rebase(top, onto);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const onDropBranch = (api) => {
-  if (api.options.nav.pane !== 'branches') return;
-  if (!api.options.canCommit()) return;
+  if (api.ui.nav.pane !== 'branches') return;
+  if (!api.ui.commits.canCommit()) return;
   const entry = selectedBranch(api);
   if (!entry || entry.current) return;
   api.state.dropName = entry.name;
-  api.options.setMode('confirmDrop');
-  api.options.setStatus('');
+  api.ui.mode = 'confirmDrop';
+  api.ui.status = '';
 };
 
 const cancelDropBranch = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.dropName = '';
-  api.options.setStatus('');
+  api.ui.status = '';
 };
 
 const dropAsync = (api, name, done, write) => {
   const run = (top) => write(top, name);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.options.runner.runBusy('dropping', done, run, after);
+  return void api.ui.ops.runBusy('dropping', done, run, after);
 };
 
 const confirmDropBranch = (api) => {
   const name = api.state.dropName;
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.dropName = '';
   if (!name) return;
   const done = `dropped ${name}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'drop', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'drop', uiOpen);
   if (picked.async) {
-    dropAsync(api, name, done, picked.write);
-    return;
+    return void dropAsync(api, name, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().drop(top, name);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.drop(top, name);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const onNewBranch = (api) => {
-  if (api.options.nav.pane !== 'branches') return;
-  if (!api.options.canCommit()) return;
-  api.options.composer.openCompose('branch', '');
+  if (api.ui.nav.pane !== 'branches') return;
+  if (!api.ui.commits.canCommit()) return;
+  api.ui.composer.openCompose('branch', '');
 };
 
 const createAsync = (api, name, done, write) => {
-  api.options.composer.closeCompose();
-  api.options.showFiles();
+  api.ui.composer.closeCompose();
+  api.ui.showFiles();
   const run = (top) => write(top, name);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void api.options.runner.runBusy('creating branch', done, run, after);
+  return void api.ui.ops.runBusy('creating branch', done, run, after);
 };
 
 const finishCreateBranch = (api) => {
-  const editor = api.options.composer.state.editor;
+  const editor = api.ui.composer.state.editor;
   const name = editor ? editor.text.trim() : '';
   if (!name) {
-    api.options.setStatus('empty branch name');
+    api.ui.status = 'empty branch name';
     return;
   }
   const done = `created ${name}`;
-  const uiOpen = api.options.uiOpen();
-  const picked = pickRepoWrite(api.options.repo(), 'createBranch', uiOpen);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(api.ui.repo, 'createBranch', uiOpen);
   if (picked.async) {
-    createAsync(api, name, done, picked.write);
-    return;
+    return void createAsync(api, name, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
-    api.options.repo().createBranch(top, name);
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    api.ui.repo.createBranch(top, name);
   });
   if (!ok) return;
-  api.options.composer.closeCompose();
-  api.options.showFiles();
+  api.ui.composer.closeCompose();
+  api.ui.showFiles();
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const onPull = (api) => {
-  if (!api.options.canCommit()) return;
-  const repo = api.options.repo();
-  const picked = pickRepoWrite(repo, 'pull', api.options.uiOpen());
+  if (!api.ui.commits.canCommit()) return;
+  const repo = api.ui.repo;
+  const picked = pickRepoWrite(repo, 'pull', api.ui.uiOpen);
   if (picked.async) {
     const after = () => refreshAfterWrite(api);
     const write = (top) => picked.write(top);
-    return void api.options.runner.runBusy('pulling', 'pulled', write, after);
+    return void api.ui.ops.runBusy('pulling', 'pulled', write, after);
   }
-  const ok = api.options.runner.runRepo('pulled', (top) => {
+  const ok = api.ui.ops.runRepo('pulled', (top) => {
     repo.pull(top);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus('pulled');
+  if (!api.ui.status) api.ui.status = 'pulled';
 };
 
 const startPush = (api, force) => {
-  if (!api.options.canCommit()) return;
+  if (!api.ui.commits.canCommit()) return;
   const done = force ? 'force pushed' : 'pushed';
   const kind = force ? 'force pushing' : 'pushing';
-  const repo = api.options.repo();
-  const picked = pickRepoWrite(repo, 'push', api.options.uiOpen());
+  const repo = api.ui.repo;
+  const picked = pickRepoWrite(repo, 'push', api.ui.uiOpen);
   if (picked.async) {
     const write = (top) => picked.write(top, force);
     const after = () => refreshAfterWrite(api);
-    return void api.options.runner.runBusy(kind, done, write, after);
+    return void api.ui.ops.runBusy(kind, done, write, after);
   }
   try {
-    repo.push(api.options.top(), force);
+    repo.push(api.ui.top, force);
   } catch (error) {
     if (error.rejected && !force) {
-      api.options.setMode('confirmPush');
-      api.options.setStatus('');
+      api.ui.mode = 'confirmPush';
+      api.ui.status = '';
       return;
     }
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   refreshAfterWrite(api);
-  api.options.setStatus(done);
+  api.ui.status = done;
 };
 
 const onPush = (api) => startPush(api, false);
 
 const onForcePush = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   startPush(api, true);
 };
 
 const cancelPush = (api) => {
-  api.options.setMode('review');
-  api.options.setStatus('');
+  api.ui.mode = 'review';
+  api.ui.status = '';
 };
 
 const reset = (state) => {
@@ -263,40 +259,32 @@ const reset = (state) => {
   state.dropName = '';
 };
 
-const createBranchController = (options) => {
+const createBranchController = (ui) => {
   const state = {
     branches: [],
     dropName: '',
   };
-  const api = { options, state };
-  return {
-    get branches() {
-      return state.branches;
-    },
-    set branches(value) {
-      state.branches = value;
-    },
-    get dropName() {
-      return state.dropName;
+  const api = { ui, state };
+  return stateView(
+    state,
+    {
+      reset: () => reset(state),
+      onBranch: () => onBranch(api),
+      onBranchMove: (delta) => onBranchMove(api, delta),
+      onCheckoutBranch: () => onCheckoutBranch(api),
+      onRebaseBranch: () => onRebaseBranch(api),
+      onDropBranch: () => onDropBranch(api),
+      cancelDropBranch: () => cancelDropBranch(api),
+      confirmDropBranch: () => confirmDropBranch(api),
+      onNewBranch: () => onNewBranch(api),
+      finishCreateBranch: () => finishCreateBranch(api),
+      onPull: () => onPull(api),
+      onPush: () => onPush(api),
+      onForcePush: () => onForcePush(api),
+      cancelPush: () => cancelPush(api),
     },
-    set dropName(value) {
-      state.dropName = value;
-    },
-    reset: () => reset(state),
-    onBranch: () => onBranch(api),
-    onBranchMove: (delta) => onBranchMove(api, delta),
-    onCheckoutBranch: () => onCheckoutBranch(api),
-    onRebaseBranch: () => onRebaseBranch(api),
-    onDropBranch: () => onDropBranch(api),
-    cancelDropBranch: () => cancelDropBranch(api),
-    confirmDropBranch: () => confirmDropBranch(api),
-    onNewBranch: () => onNewBranch(api),
-    finishCreateBranch: () => finishCreateBranch(api),
-    onPull: () => onPull(api),
-    onPush: () => onPush(api),
-    onForcePush: () => onForcePush(api),
-    cancelPush: () => cancelPush(api),
-  };
+    ['branches', 'dropName'],
+  );
 };
 
 module.exports = { createBranchController };