reslop 0.2.5 → 0.2.7

package/lib/session/branches.js

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