reslop 0.1.9 → 0.2.1

package/lib/session/commit.js

@@ -1,56 +1,68 @@
 'use strict';
 
-const { isReadOnlyOrigin } = require('./origins.js');
+const { stateView } = require('./accessors.js');
+
+const { isReadOnlyOrigin } = require('../files.js');
+const { isFixupCommit } = require('./actions.js');
 const { pickRepoWrite } = require('./ops.js');
 
 const COMMIT_STATUS = {
   commit: 'committed',
   amend: 'amended',
   fixup: 'fixup',
+  reword: 'reworded',
+};
+
+const isInPlaceCommit = (kind) => kind === 'amend' || kind === 'reword';
+
+const fixupMessage = (entry) => {
+  const subject = `${entry && entry.subject ? entry.subject : ''}`.trim();
+  if (!subject) return 'fixup!';
+  return `fixup! ${subject}`;
 };
 
-const canCommit = (options) => {
-  const caps = options.capabilities();
+const canCommit = (ui) => {
+  const caps = ui.capabilities;
   if (!caps.branches) {
-    options.setStatus('read only');
+    ui.status = 'read only';
     return false;
   }
-  for (const item of options.getItems()) {
+  for (const item of ui.items) {
     if (isReadOnlyOrigin(item.origin)) {
-      options.setStatus('read only');
+      ui.status = 'read only';
       return false;
     }
   }
   return true;
 };
 
-const hasStagedChanges = (options) => {
-  const repo = options.repo();
-  if (repo.hasStaged) return repo.hasStaged(options.top());
-  for (const item of options.getItems()) {
+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;
 };
 
 const selectedCommit = (api) => {
-  const cursor = api.options.nav.commitCursor;
+  const cursor = api.ui.nav.commitCursor;
   return api.state.commits[cursor] ?? null;
 };
 
 const clampCommitCursor = (api) => {
   const last = api.state.commits.length - 1;
-  const nav = api.options.nav;
+  const nav = api.ui.nav;
   if (nav.commitCursor > last) nav.commitCursor = Math.max(0, last);
 };
 
 const refreshCommitList = (api) => {
-  const repo = api.options.repo();
+  const repo = api.ui.repo;
   if (!repo.listCommits) return;
   try {
-    api.state.commits = repo.listCommits(api.options.top());
+    api.state.commits = repo.listCommits(api.ui.top);
   } catch (error) {
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
   clampCommitCursor(api);
@@ -58,185 +70,264 @@ const refreshCommitList = (api) => {
 
 const refreshAfterWrite = (api, extra = {}) => {
   refreshCommitList(api);
-  api.options.refreshFromRepo({ keepEmpty: true, ...extra });
+  api.ui.refreshFromRepo({ keepEmpty: true, ...extra });
 };
 
 const showCommits = (api) => {
-  if (api.options.getMode() === 'compose') return;
-  if (!canCommit(api.options)) return;
-  const repo = api.options.repo();
+  if (api.ui.mode === 'compose') return;
+  if (!canCommit(api.ui)) return;
+  const repo = api.ui.repo;
   if (!repo.listCommits) {
-    api.options.setStatus('read only');
+    api.ui.status = 'read only';
     return;
   }
   try {
-    api.state.commits = repo.listCommits(api.options.top());
+    api.state.commits = repo.listCommits(api.ui.top);
   } catch (error) {
-    api.options.setStatus(error.message);
+    api.ui.status = error.message;
     return;
   }
-  api.options.nav.commitCursor = 0;
-  api.options.nav.pane = 'commits';
-  api.options.setStatus('');
-  api.options.nav.clearSelection();
+  api.ui.nav.commitCursor = 0;
+  api.ui.nav.pane = 'commits';
+  api.ui.status = '';
+  api.ui.nav.clearSelection();
 };
 
 const onCommitMove = (api, delta) => {
   const commits = api.state.commits;
   if (!commits.length) {
-    api.options.setStatus('nothing to review');
+    api.ui.status = 'nothing to review';
     return;
   }
   const next = Math.min(
     commits.length - 1,
-    Math.max(0, api.options.nav.commitCursor + delta),
+    Math.max(0, api.ui.nav.commitCursor + delta),
   );
-  if (next === api.options.nav.commitCursor) return;
-  api.options.nav.commitCursor = next;
-  api.options.setStatus('');
+  if (next === api.ui.nav.commitCursor) return;
+  api.ui.nav.commitCursor = next;
+  api.ui.status = '';
 };
 
 const startGitCommit = (api, kind) => {
-  const options = api.options;
-  if (kind !== 'amend' && !hasStagedChanges(options)) {
-    options.setMode('review');
-    options.composer.state.commitKind = null;
-    options.setStatus('nothing to commit');
+  const ui = api.ui;
+  if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+    ui.mode = 'review';
+    ui.composer.state.commitKind = null;
+    ui.status = 'nothing to commit';
     return;
   }
-  options.composer.state.commitKind = kind;
   let text = '';
   if (kind === 'fixup') {
-    const entry = selectedCommit(api);
-    text = entry ? entry.shortSha || entry.sha : 'HEAD';
+    text = fixupMessage(selectedCommit(api));
+  }
+  if (kind === 'amend') {
+    const headAt = api.state.commits.findIndex((entry) => entry.head);
+    api.ui.nav.commitCursor = headAt < 0 ? 0 : headAt;
+    if (ui.repo.lastMessage) {
+      text = ui.repo.lastMessage(ui.top) ?? '';
+    }
   }
-  if (kind === 'amend' && options.repo().lastMessage) {
-    text = options.repo().lastMessage(options.top()) ?? '';
+  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 = `${entry.subject ?? ''}`;
+    }
   }
-  options.composer.openCompose('commit', text);
+  ui.composer.state.commitKind = kind;
+  ui.composer.openCompose('commit', text);
 };
 
 const onCommit = (api) => {
-  if (api.options.nav.pane !== 'commits') return void showCommits(api);
-  if (!canCommit(api.options)) return;
+  if (api.ui.nav.pane !== 'commits') return void showCommits(api);
+  if (!canCommit(api.ui)) return;
   startGitCommit(api, 'commit');
 };
 
 const onAmend = (api) => {
-  if (api.options.nav.pane !== 'commits') return;
-  if (!canCommit(api.options)) return;
+  if (api.ui.nav.pane !== 'commits') return;
+  if (!canCommit(api.ui)) return;
+  startGitCommit(api, 'amend');
+};
+
+const onReword = (api) => {
+  if (api.ui.nav.pane !== 'commits') return;
+  if (!canCommit(api.ui)) return;
+  startGitCommit(api, 'reword');
+};
+
+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;
+  }
+  const picked = pickRepoWrite(repo, 'applyFixup', api.ui.uiOpen);
+  if (picked.async) {
+    const run = (top) => picked.write(top, entry.sha);
+    const after = () => refreshAfterWrite(api, { doneStatus: done });
+    return void api.ui.ops.runBusy('applying', done, run, after);
+  }
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    repo.applyFixup(top, entry.sha);
+  });
+  if (!ok) return;
+  refreshAfterWrite(api);
+  if (!api.ui.status) api.ui.status = done;
+};
+
+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');
 };
 
 const onFixup = (api) => {
-  if (api.options.nav.pane !== 'commits') return;
-  if (!canCommit(api.options)) return;
+  if (api.ui.nav.pane !== 'commits') return;
+  if (!canCommit(api.ui)) return;
   startGitCommit(api, 'fixup');
 };
 
 const cancelCommit = (api) => {
-  api.options.setMode('review');
-  api.options.composer.state.commitKind = null;
-  api.options.setStatus('');
+  api.ui.mode = 'review';
+  api.ui.composer.state.commitKind = null;
+  api.ui.status = '';
 };
 
 const finishAsyncCommit = (api, kind, message, done, write) => {
-  const options = api.options;
-  options.composer.closeCompose();
+  const ui = api.ui;
+  ui.composer.closeCompose();
   const run = (top) => write(top, kind, message);
   const after = () => refreshAfterWrite(api, { doneStatus: done });
-  return void options.runner.runBusy('committing', done, run, after);
+  return void ui.ops.runBusy('committing', done, run, after);
 };
 
 const finishSyncCommit = (api, kind, message, done) => {
-  const options = api.options;
+  const ui = api.ui;
   try {
-    options.repo().commit(options.top(), kind, message);
+    ui.repo.commit(ui.top, kind, message);
   } catch (error) {
-    options.setStatus(error.message);
+    ui.status = error.message;
     return;
   }
-  options.composer.closeCompose();
-  options.collection.clearDismissed();
+  ui.composer.closeCompose();
+  ui.collection.clearDismissed();
   refreshAfterWrite(api);
-  if (!options.isDone() && !options.pendingExtras()) {
-    options.setStatus(done);
+  if (!ui.done && !ui.pendingExtras) {
+    ui.status = done;
   }
 };
 
+const finishReword = (api, message) => {
+  const ui = api.ui;
+  const entry = selectedCommit(api);
+  if (!entry || !entry.sha) {
+    ui.status = 'read only';
+    return;
+  }
+  const done = COMMIT_STATUS.reword;
+  const repo = ui.repo;
+  if (!repo.reword) {
+    ui.status = 'read only';
+    return;
+  }
+  const picked = pickRepoWrite(repo, 'reword', ui.uiOpen);
+  if (picked.async) {
+    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);
+  }
+  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 options = api.options;
-  const kind = options.composer.state.commitKind;
-  const editor = options.composer.state.editor;
+  const ui = api.ui;
+  const kind = ui.composer.state.commitKind;
+  const editor = ui.composer.state.editor;
   const message = editor ? editor.text : '';
-  if (kind !== 'fixup' && !message.trim()) {
-    options.setStatus('empty commit message');
+  if (!message.trim()) {
+    ui.status = 'empty commit message';
     return;
   }
-  if (kind !== 'amend' && !hasStagedChanges(options)) {
-    options.composer.closeCompose();
-    options.setStatus('nothing to commit');
+  if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+    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 = options.uiOpen();
-  const picked = pickRepoWrite(options.repo(), 'commit', uiOpen);
+  const uiOpen = ui.uiOpen;
+  const picked = pickRepoWrite(ui.repo, 'commit', uiOpen);
   if (picked.async) {
-    finishAsyncCommit(api, kind, message, done, picked.write);
-    return;
+    return void finishAsyncCommit(api, kind, message, done, picked.write);
   }
   finishSyncCommit(api, kind, message, done);
 };
 
 const onDropCommit = (api) => {
-  if (api.options.nav.pane !== 'commits') return;
-  if (!canCommit(api.options)) return;
+  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.options.setMode('confirmDrop');
-  api.options.setStatus('');
+  api.ui.mode = 'confirmDrop';
+  api.ui.status = '';
 };
 
 const cancelDropCommit = (api) => {
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.dropName = '';
   api.state.dropSha = '';
-  api.options.setStatus('');
+  api.ui.status = '';
 };
 
 const dropAsync = (api, sha, done, write) => {
   const run = (top) => write(top, sha);
   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 confirmDropCommit = (api) => {
   const sha = api.state.dropSha;
   const name = api.state.dropName;
-  api.options.setMode('review');
+  api.ui.mode = 'review';
   api.state.dropName = '';
   api.state.dropSha = '';
   if (!sha) return;
   const done = `dropped ${name}`;
-  const repo = api.options.repo();
+  const repo = api.ui.repo;
   if (!repo.dropCommit) {
-    api.options.setStatus('read only');
+    api.ui.status = 'read only';
     return;
   }
-  const uiOpen = api.options.uiOpen();
+  const uiOpen = api.ui.uiOpen;
   const picked = pickRepoWrite(repo, 'dropCommit', uiOpen);
   if (picked.async) {
-    dropAsync(api, sha, done, picked.write);
-    return;
+    return void dropAsync(api, sha, done, picked.write);
   }
-  const ok = api.options.runner.runRepo(done, (top) => {
+  const ok = api.ui.ops.runRepo(done, (top) => {
     repo.dropCommit(top, sha);
   });
   if (!ok) return;
   refreshAfterWrite(api);
-  if (!api.options.getStatus()) api.options.setStatus(done);
+  if (!api.ui.status) api.ui.status = done;
 };
 
 const reset = (state) => {
@@ -245,39 +336,34 @@ const reset = (state) => {
   state.dropSha = '';
 };
 
-const createCommitController = (options) => {
+const createCommitController = (ui) => {
   const state = {
     commits: [],
     dropName: '',
     dropSha: '',
   };
-  const api = { options, state };
-  return {
-    get commits() {
-      return state.commits;
+  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),
+      cancelCommit: () => cancelCommit(api),
+      startGitCommit: (kind) => startGitCommit(api, kind),
+      finishGitCommit: () => finishGitCommit(api),
+      refresh: () => refreshCommitList(api),
+      onDropCommit: () => onDropCommit(api),
+      cancelDropCommit: () => cancelDropCommit(api),
+      confirmDropCommit: () => confirmDropCommit(api),
     },
-    set commits(value) {
-      state.commits = value;
-    },
-    get dropName() {
-      return state.dropName;
-    },
-    set dropName(value) {
-      state.dropName = value;
-    },
-    reset: () => reset(state),
-    canCommit: () => canCommit(options),
-    onCommit: () => onCommit(api),
-    onAmend: () => onAmend(api),
-    onFixup: () => onFixup(api),
-    onCommitMove: (delta) => onCommitMove(api, delta),
-    cancelCommit: () => cancelCommit(api),
-    startGitCommit: (kind) => startGitCommit(api, kind),
-    finishGitCommit: () => finishGitCommit(api),
-    onDropCommit: () => onDropCommit(api),
-    cancelDropCommit: () => cancelDropCommit(api),
-    confirmDropCommit: () => confirmDropCommit(api),
-  };
+    ['commits', 'dropName'],
+  );
 };
 
 module.exports = {