reslop 0.2.5 → 0.2.7

package/lib/session/commit.js

@@ -1,8 +1,5 @@
 'use strict';
 
-const accessors = require('./accessors.js');
-const { stateView } = accessors;
-
 const files = require('../files.js');
 const { isReadOnlyOrigin } = files;
 const actions = require('./actions.js');
@@ -37,10 +34,6 @@ const PENDING_COMMIT = {
 
 const listedCommits = (commits) => [PENDING_COMMIT].concat(commits ?? []);
 
-const isPending = (entry) => Boolean(entry && entry.pending);
-
-const briefCommit = (ui) => ui.commits.commitView !== 'full';
-
 const joinMessage = (line, rest) => (rest ? `${line}\n${rest}` : line);
 
 const tidyCommitMessage = (message) => {
@@ -50,402 +43,355 @@ const tidyCommitMessage = (message) => {
   return lines.join('\n');
 };
 
-const keepBriefBody = (ui, text) => {
-  if (!briefCommit(ui)) return text;
-  const parts = splitMessage(text);
-  ui.composer.state.commitBody = parts.rest;
-  return parts.line;
-};
-
 const fixupMessage = (entry) => {
   const subject = commitLine(entry).trim();
   if (!subject) return 'fixup!';
   return `fixup! ${subject}`;
 };
 
-const canCommit = (ui) => {
-  const caps = ui.capabilities;
-  if (!caps.branches) {
-    ui.status = 'read only';
-    return false;
-  }
-  for (const item of ui.items) {
-    if (isReadOnlyOrigin(item.origin)) {
-      ui.status = 'read only';
-      return false;
-    }
-  }
-  return true;
-};
-
 const hasStagedChanges = (ui) => {
   const repo = ui.repo;
   if (repo.hasStaged) return repo.hasStaged(ui.top);
-  for (const item of ui.items) {
-    if (item.origin === 'staged') return true;
-  }
-  return false;
+  return ui.items.some((item) => item.origin === 'staged');
 };
 
-const selectedCommit = (api) => {
-  const cursor = api.ui.nav.commitCursor;
-  return listedCommits(api.state.commits)[cursor] ?? null;
-};
+class CommitController {
+  constructor(ui) {
+    this.ui = ui;
+    this.reset();
+  }
 
-const clampCommitCursor = (api) => {
-  const last = listedCommits(api.state.commits).length - 1;
-  const nav = api.ui.nav;
-  if (nav.commitCursor > last) nav.commitCursor = Math.max(0, last);
-};
+  reset() {
+    this.commits = [];
+    this.dropName = '';
+    this.dropSha = '';
+    this.commitView = 'brief';
+  }
 
-const commitIndexForView = (api) => {
-  const ui = api.ui;
-  if (hasStagedChanges(ui)) return 0;
-  const list = listedCommits(api.state.commits);
-  const want = `${ui.rev ?? ''}`;
-  const short = `${ui.revShort ?? ''}`;
-  if (!want && !short) return 0;
-  for (let i = 0; i < list.length; i++) {
-    const entry = list[i];
-    if (!entry || entry.pending) continue;
-    const sha = `${entry.sha ?? ''}`;
-    const brief = `${entry.shortSha ?? ''}`;
-    if (want && sha === want) return i;
-    if (short && (brief === short || sha.startsWith(short))) return i;
+  get brief() {
+    return this.commitView !== 'full';
   }
-  return 0;
-};
 
-const refreshCommitList = (api) => {
-  const repo = api.ui.repo;
-  if (!repo.listCommits) return;
-  try {
-    api.state.commits = repo.listCommits(api.ui.top);
-  } catch (error) {
-    api.ui.status = error.message;
-    return;
+  canCommit() {
+    const ui = this.ui;
+    const readOnly =
+      !ui.capabilities.branches ||
+      ui.items.some((item) => isReadOnlyOrigin(item.origin));
+    if (readOnly) ui.status = 'read only';
+    return !readOnly;
   }
-  clampCommitCursor(api);
-};
 
-const refreshAfterWrite = (api, extra = {}) => {
-  refreshCommitList(api);
-  api.ui.refreshFromRepo({ keepEmpty: true, ...extra });
-};
+  canWrite() {
+    return this.ui.nav.pane === 'commits' && this.canCommit();
+  }
 
-const showCommits = (api) => {
-  if (api.ui.mode === 'compose') return;
-  const repo = api.ui.repo;
-  if (!repo.listCommits) {
-    api.ui.status = 'read only';
-    return;
+  selected() {
+    return listedCommits(this.commits)[this.ui.nav.commitCursor] ?? null;
   }
-  try {
-    api.state.commits = repo.listCommits(api.ui.top);
-  } catch (error) {
-    api.ui.status = error.message;
-    return;
+
+  loadCommits() {
+    const ui = this.ui;
+    try {
+      this.commits = ui.repo.listCommits(ui.top);
+      return true;
+    } catch (error) {
+      ui.status = error.message;
+      return false;
+    }
   }
-  const nav = api.ui.nav;
-  nav.commitCursor = commitIndexForView(api);
-  nav.pane = 'commits';
-  nav.resetListScroll('commits');
-  api.ui.status = '';
-  nav.clearSelection();
-};
 
-const onCommitMove = (api, delta) => {
-  if (api.ui.mode === 'compose') return;
-  const commits = listedCommits(api.state.commits);
-  const next = Math.min(
-    commits.length - 1,
-    Math.max(0, api.ui.nav.commitCursor + delta),
-  );
-  if (next === api.ui.nav.commitCursor) return;
-  api.ui.nav.commitCursor = next;
-  api.ui.status = '';
-};
+  refresh() {
+    if (!this.ui.repo.listCommits || !this.loadCommits()) return;
+    const last = listedCommits(this.commits).length - 1;
+    const nav = this.ui.nav;
+    if (nav.commitCursor > last) nav.commitCursor = Math.max(0, last);
+  }
 
-const startGitCommit = (api, kind) => {
-  const ui = api.ui;
-  if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
-    ui.mode = 'review';
-    ui.composer.state.commitKind = null;
-    ui.status = 'nothing to commit';
-    return;
+  refreshAfterWrite(extra = {}) {
+    this.refresh();
+    this.ui.refreshFromRepo({ keepEmpty: true, ...extra });
   }
-  let text = '';
-  if (kind === 'fixup') text = fixupMessage(selectedCommit(api));
-  if (kind === 'commit') api.ui.nav.commitCursor = 0;
-  if (kind === 'amend') {
-    const headAt = api.state.commits.findIndex((entry) => entry.head);
-    const at = headAt < 0 ? 0 : headAt;
-    api.ui.nav.commitCursor = api.state.commits.length ? at + 1 : 0;
-    if (ui.repo.lastMessage) text = ui.repo.lastMessage(ui.top) ?? '';
+
+  indexForView() {
+    const ui = this.ui;
+    if (hasStagedChanges(ui)) return 0;
+    const list = listedCommits(this.commits);
+    const want = `${ui.rev ?? ''}`;
+    const short = `${ui.revShort ?? ''}`;
+    if (!want && !short) return 0;
+    for (let i = 0; i < list.length; i++) {
+      const entry = list[i];
+      if (entry.pending) continue;
+      const sha = `${entry.sha ?? ''}`;
+      const brief = `${entry.shortSha ?? ''}`;
+      if (want && sha === want) return i;
+      if (short && (brief === short || sha.startsWith(short))) return i;
+    }
+    return 0;
   }
-  if (kind === 'reword') {
-    const entry = selectedCommit(api);
-    if (!entry || !entry.sha) return;
-    if (typeof ui.repo.commitMessage === 'function') {
-      text = ui.repo.commitMessage(ui.top, entry.sha) ?? '';
-    } else {
-      text = commitText(entry);
+
+  show() {
+    const ui = this.ui;
+    if (ui.mode === 'compose') return;
+    if (!ui.repo.listCommits) {
+      ui.status = 'read only';
+      return;
     }
+    if (!this.loadCommits()) return;
+    const nav = ui.nav;
+    nav.commitCursor = this.indexForView();
+    nav.pane = 'commits';
+    nav.resetListScroll('commits');
+    ui.status = '';
+    nav.clearSelection();
   }
-  ui.composer.state.commitBody = '';
-  if (isInPlaceCommit(kind)) text = keepBriefBody(ui, text);
-  ui.composer.state.commitKind = kind;
-  ui.composer.openCompose('commit', text);
-  const editor = ui.composer.state.editor;
-  if (!editor) return;
-  const lineEnd = editor.text.indexOf('\n');
-  editor.cursor = lineEnd < 0 ? editor.text.length : lineEnd;
-};
 
-const onCommit = (api) => {
-  if (api.ui.nav.pane !== 'commits') return void showCommits(api);
-  if (!canCommit(api.ui)) return;
-  api.ui.nav.commitCursor = 0;
-  startGitCommit(api, 'commit');
-};
+  onCommitMove(delta) {
+    const nav = this.ui.nav;
+    if (this.ui.mode === 'compose') return;
+    const last = listedCommits(this.commits).length - 1;
+    const next = Math.min(last, Math.max(0, nav.commitCursor + delta));
+    if (next === nav.commitCursor) return;
+    nav.commitCursor = next;
+    this.ui.status = '';
+  }
 
-const openLoadedDiff = (ui) => {
-  ui.nav.tasksOpen = false;
-  ui.nav.scroll = 0;
-  ui.nav.index = 0;
-  ui.nav.pane = ui.items.length ? 'diff' : 'files';
-  ui.syncReviewPath();
-  ui.syncFileCursor();
-  ui.status = '';
-};
+  messageFor(kind) {
+    const ui = this.ui;
+    if (kind === 'fixup') return fixupMessage(this.selected());
+    if (kind === 'amend') {
+      const headAt = this.commits.findIndex((entry) => entry.head);
+      const at = headAt < 0 ? 0 : headAt;
+      ui.nav.commitCursor = this.commits.length ? at + 1 : 0;
+      if (ui.repo.lastMessage) return ui.repo.lastMessage(ui.top) ?? '';
+      return '';
+    }
+    if (kind === 'reword') {
+      const entry = this.selected();
+      if (!entry || !entry.sha) return null;
+      if (!ui.repo.commitMessage) return commitText(entry);
+      return ui.repo.commitMessage(ui.top, entry.sha) ?? '';
+    }
+    ui.nav.commitCursor = 0;
+    return '';
+  }
 
-const showSelectedDiff = (api) => {
-  if (api.ui.mode === 'compose') return;
-  const entry = selectedCommit(api);
-  if (!entry) return;
-  const ui = api.ui;
-  const viewingCommit = Boolean(ui.rev || ui.revShort);
-  if (isPending(entry) && !viewingCommit) return void onCommit(api);
-  if (isPending(entry) || !entry.sha) {
-    ui.rev = '';
-    ui.revShort = '';
-  } else {
-    ui.rev = entry.sha;
-    ui.revShort = entry.shortSha || '';
+  start(kind) {
+    const ui = this.ui;
+    const composer = ui.composer;
+    if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+      ui.mode = 'review';
+      composer.commitKind = null;
+      ui.status = 'nothing to commit';
+      return;
+    }
+    let text = this.messageFor(kind);
+    if (text === null) return;
+    composer.commitBody = '';
+    if (isInPlaceCommit(kind) && this.brief) {
+      const parts = splitMessage(text);
+      composer.commitBody = parts.rest;
+      text = parts.line;
+    }
+    composer.commitKind = kind;
+    ui.composer.openCompose('commit', text);
+    const editor = composer.editor;
+    const lineEnd = editor.text.indexOf('\n');
+    editor.cursor = lineEnd < 0 ? editor.text.length : lineEnd;
   }
-  ui.refreshFromRepo({
-    keepEmpty: true,
-    afterLoad: () => openLoadedDiff(ui),
-  });
-};
 
-const onAmend = (api) => {
-  if (api.ui.nav.pane !== 'commits') return;
-  if (!canCommit(api.ui)) return;
-  startGitCommit(api, 'amend');
-};
+  onInsert() {
+    const entry = this.selected();
+    if (!entry || entry.pending || !entry.sha) {
+      if (this.canCommit()) this.start('commit');
+      return;
+    }
+    if (!this.canWrite()) return;
+    this.ui.status = '';
+    this.ui.mode = 'confirmCommit';
+  }
 
-const onReword = (api) => {
-  if (api.ui.nav.pane !== 'commits') return;
-  if (!canCommit(api.ui)) return;
-  startGitCommit(api, 'reword');
-};
+  chooseCommit(kind) {
+    this.ui.mode = 'review';
+    if (kind === 'amend') {
+      this.onAmend();
+      return;
+    }
+    if (kind === 'fixup') {
+      this.onFixup();
+      return;
+    }
+    this.start('commit');
+  }
 
-const applyFixupNow = (api) => {
-  const entry = selectedCommit(api);
-  if (!entry || !entry.sha) return;
-  const done = 'applied';
-  const repo = api.ui.repo;
-  if (!repo.applyFixup) {
-    api.ui.status = 'read only';
-    return;
+  cancelCommitChoice() {
+    this.ui.mode = 'review';
   }
-  api.ui.ops.runWrite('applyFixup', [entry.sha], 'applying', done, (extra) =>
-    refreshAfterWrite(api, extra),
-  );
-};
 
-const onApply = (api) => {
-  if (api.ui.nav.pane !== 'commits') return;
-  if (!canCommit(api.ui)) return;
-  const entry = selectedCommit(api);
-  if (isFixupCommit(entry)) return void applyFixupNow(api);
-  startGitCommit(api, 'amend');
-};
+  onCommit() {
+    if (this.ui.nav.pane === 'commits') return;
+    this.show();
+  }
 
-const onFixup = (api) => {
-  if (api.ui.nav.pane !== 'commits') return;
-  if (!canCommit(api.ui)) return;
-  startGitCommit(api, 'fixup');
-};
+  onShowDiff() {
+    const ui = this.ui;
+    if (ui.mode === 'compose') return;
+    const entry = this.selected();
+    if (!entry) return;
+    const viewingCommit = Boolean(ui.rev || ui.revShort);
+    if (entry.pending && !viewingCommit) return void this.onInsert();
+    const sha = entry.pending ? '' : entry.sha || '';
+    ui.rev = sha;
+    ui.revShort = sha ? entry.shortSha || '' : '';
+    const afterLoad = () => {
+      const nav = ui.nav;
+      nav.tasksOpen = false;
+      nav.scroll = 0;
+      nav.index = 0;
+      nav.pane = ui.items.length ? 'diff' : 'files';
+      ui.syncReviewPath();
+      ui.syncFileCursor();
+      ui.status = '';
+    };
+    ui.refreshFromRepo({ keepEmpty: true, afterLoad });
+  }
 
-const finishAsyncCommit = (api, kind, message, done, write) => {
-  const ui = api.ui;
-  ui.composer.closeCompose();
-  const run = (top) => write(top, kind, message);
-  const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void ui.ops.runBusy('committing', done, run, after);
-};
+  onAmend() {
+    if (this.canWrite()) this.start('amend');
+  }
 
-const finishSyncCommit = (api, kind, message, done) => {
-  const ui = api.ui;
-  try {
-    ui.repo.commit(ui.top, kind, message);
-  } catch (error) {
-    ui.status = error.message;
-    return;
+  onReword() {
+    if (this.canWrite()) this.start('reword');
   }
-  ui.composer.closeCompose();
-  ui.collection.clearDismissed();
-  refreshAfterWrite(api);
-  if (!ui.done && !ui.pendingExtras) {
-    ui.status = done;
+
+  onFixup() {
+    if (this.canWrite()) this.start('fixup');
   }
-};
 
-const finishReword = (api, message) => {
-  const ui = api.ui;
-  const entry = selectedCommit(api);
-  if (!entry || !entry.sha) {
-    ui.status = 'read only';
-    return;
+  onApply() {
+    if (!this.canWrite()) return;
+    const entry = this.selected();
+    if (!isFixupCommit(entry)) return void this.start('amend');
+    if (!entry.sha) return;
+    if (!this.ui.repo.applyFixup) {
+      this.ui.status = 'read only';
+      return;
+    }
+    const after = (extra) => this.refreshAfterWrite(extra);
+    this.ui.ops.runWrite(
+      'applyFixup',
+      [entry.sha],
+      'applying',
+      'applied',
+      after,
+    );
   }
-  const done = COMMIT_STATUS.reword;
-  const repo = ui.repo;
-  if (!repo.reword) {
-    ui.status = 'read only';
-    return;
+
+  runAsync(kind, done, run) {
+    this.ui.composer.closeCompose();
+    const after = () => this.refreshAfterWrite({ doneStatus: done });
+    this.ui.ops.runBusy(kind, done, run, after);
   }
-  const picked = pickRepoWrite(repo, 'reword', ui.uiOpen);
-  if (picked.async) {
+
+  finishReword(message) {
+    const ui = this.ui;
+    const entry = this.selected();
+    if (!entry || !entry.sha || !ui.repo.reword) {
+      ui.status = 'read only';
+      return;
+    }
+    const done = COMMIT_STATUS.reword;
+    const picked = pickRepoWrite(ui.repo, 'reword', ui.uiOpen);
+    if (picked.async) {
+      const run = (top) => picked.write(top, entry.sha, message);
+      return void this.runAsync('rewording', done, run);
+    }
+    try {
+      ui.repo.reword(ui.top, entry.sha, message);
+    } catch (error) {
+      ui.status = error.message;
+      return;
+    }
     ui.composer.closeCompose();
-    const run = (top) => picked.write(top, entry.sha, message);
-    const after = () => refreshAfterWrite(api, { doneStatus: done });
-    return void ui.ops.runBusy('rewording', done, run, after);
+    this.refreshAfterWrite();
+    if (!ui.status) ui.status = done;
   }
-  try {
-    repo.reword(ui.top, entry.sha, message);
-  } catch (error) {
-    ui.status = error.message;
-    return;
-  }
-  ui.composer.closeCompose();
-  refreshAfterWrite(api);
-  if (!ui.status) ui.status = done;
-};
 
-const finishGitCommit = (api) => {
-  const ui = api.ui;
-  const kind = ui.composer.state.commitKind;
-  const editor = ui.composer.state.editor;
-  let message = editor ? editor.text : '';
-  if (isInPlaceCommit(kind) && briefCommit(ui)) {
-    message = joinMessage(message, ui.composer.state.commitBody);
-  }
-  message = tidyCommitMessage(message);
-  if (!message.trim()) {
-    ui.status = 'empty commit message';
-    return;
-  }
-  if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+  finishGitCommit() {
+    const ui = this.ui;
+    const composer = ui.composer;
+    const kind = composer.commitKind;
+    let message = composer.editor ? composer.editor.text : '';
+    if (isInPlaceCommit(kind) && this.brief) {
+      message = joinMessage(message, composer.commitBody);
+    }
+    message = tidyCommitMessage(message);
+    if (!message.trim()) {
+      ui.status = 'empty commit message';
+      return;
+    }
+    if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+      ui.composer.closeCompose();
+      ui.status = 'nothing to commit';
+      return;
+    }
+    if (kind === 'reword') return void this.finishReword(message);
+    const done = COMMIT_STATUS[kind] ?? 'committed';
+    const picked = pickRepoWrite(ui.repo, 'commit', ui.uiOpen);
+    if (picked.async) {
+      const run = (top) => picked.write(top, kind, message);
+      return void this.runAsync('committing', done, run);
+    }
+    try {
+      ui.repo.commit(ui.top, kind, message);
+    } catch (error) {
+      ui.status = error.message;
+      return;
+    }
     ui.composer.closeCompose();
-    ui.status = 'nothing to commit';
-    return;
-  }
-  if (kind === 'reword') return void finishReword(api, message);
-  const done = COMMIT_STATUS[kind] ?? 'committed';
-  const uiOpen = ui.uiOpen;
-  const picked = pickRepoWrite(ui.repo, 'commit', uiOpen);
-  if (picked.async) {
-    return void finishAsyncCommit(api, kind, message, done, picked.write);
+    ui.collection.clearDismissed();
+    this.refreshAfterWrite();
+    if (!ui.done && !ui.pendingExtras) ui.status = done;
   }
-  finishSyncCommit(api, kind, message, done);
-};
-
-const onDropCommit = (api) => {
-  if (api.ui.nav.pane !== 'commits') return;
-  if (!canCommit(api.ui)) return;
-  const entry = selectedCommit(api);
-  if (!entry) return;
-  api.state.dropName = entry.shortSha || entry.sha;
-  api.state.dropSha = entry.sha;
-  api.ui.mode = 'confirmDrop';
-  api.ui.status = '';
-};
 
-const cancelDropCommit = (api) => {
-  api.ui.mode = 'review';
-  api.state.dropName = '';
-  api.state.dropSha = '';
-  api.ui.status = '';
-};
-
-const confirmDropCommit = (api) => {
-  const sha = api.state.dropSha;
-  const name = api.state.dropName;
-  api.ui.mode = 'review';
-  api.state.dropName = '';
-  api.state.dropSha = '';
-  if (!sha) return;
-  const done = `dropped ${name}`;
-  const repo = api.ui.repo;
-  if (!repo.dropCommit) {
-    api.ui.status = 'read only';
-    return;
+  onDropCommit() {
+    if (!this.canWrite()) return;
+    const entry = this.selected();
+    if (!entry) return;
+    this.dropName = entry.shortSha || entry.sha;
+    this.dropSha = entry.sha;
+    this.ui.mode = 'confirmDrop';
+    this.ui.status = '';
   }
-  api.ui.ops.runWrite('dropCommit', [sha], 'dropping', done, (extra) =>
-    refreshAfterWrite(api, extra),
-  );
-};
 
-const onView = (api) => {
-  if (api.ui.nav.pane !== 'commits') return;
-  const next = api.state.commitView === 'full' ? 'brief' : 'full';
-  api.state.commitView = next;
-  api.ui.nav.listScroll = 0;
-  api.ui.status = next;
-};
+  cancelDropCommit() {
+    this.ui.mode = 'review';
+    this.dropName = '';
+    this.dropSha = '';
+    this.ui.status = '';
+  }
 
-const reset = (state) => {
-  state.commits = [];
-  state.dropName = '';
-  state.dropSha = '';
-  state.commitView = 'brief';
-};
+  confirmDropCommit() {
+    const sha = this.dropSha;
+    const done = `dropped ${this.dropName}`;
+    this.ui.mode = 'review';
+    this.dropName = '';
+    this.dropSha = '';
+    if (!sha) return;
+    if (!this.ui.repo.dropCommit) {
+      this.ui.status = 'read only';
+      return;
+    }
+    const after = (extra) => this.refreshAfterWrite(extra);
+    this.ui.ops.runWrite('dropCommit', [sha], 'dropping', done, after);
+  }
 
-const createCommitController = (ui) => {
-  const state = {
-    commits: [],
-    dropName: '',
-    dropSha: '',
-    commitView: 'brief',
-  };
-  const api = { ui, state };
-  return stateView(
-    state,
-    {
-      reset: () => reset(state),
-      canCommit: () => canCommit(ui),
-      onCommit: () => onCommit(api),
-      onAmend: () => onAmend(api),
-      onReword: () => onReword(api),
-      onApply: () => onApply(api),
-      onFixup: () => onFixup(api),
-      onCommitMove: (delta) => onCommitMove(api, delta),
-      onShowDiff: () => showSelectedDiff(api),
-      onView: () => onView(api),
-      finishGitCommit: () => finishGitCommit(api),
-      refresh: () => refreshCommitList(api),
-      onDropCommit: () => onDropCommit(api),
-      cancelDropCommit: () => cancelDropCommit(api),
-      confirmDropCommit: () => confirmDropCommit(api),
-    },
-    ['commits', 'dropName', 'commitView'],
-  );
-};
+  onView() {
+    if (this.ui.nav.pane !== 'commits') return;
+    this.commitView = this.brief ? 'full' : 'brief';
+    this.ui.nav.listScroll = 0;
+    this.ui.status = this.commitView;
+  }
+}
 
-module.exports = {
-  hasStagedChanges,
-  createCommitController,
-  listedCommits,
-};
+module.exports = { hasStagedChanges, listedCommits, CommitController };