reslop 0.2.6 → 0.3.0

package/lib/session/commit.js

@@ -1,11 +1,8 @@
 'use strict';
 
-const files = require('../files.js');
-const { isReadOnlyOrigin } = files;
-const actions = require('./actions.js');
-const { isFixupCommit } = actions;
-const ops = require('./ops.js');
-const { pickRepoWrite } = ops;
+const { isReadOnlyOrigin } = require('../common/files.js');
+const { saveUiPrefs } = require('./prefs.js');
+const { isFixupCommit } = require('../input/actions.js');
 const commits = require('../render/commits.js');
 const { commitLine, commitText, splitMessage } = commits;
 
@@ -49,7 +46,7 @@ const fixupMessage = (entry) => {
   return `fixup! ${subject}`;
 };
 
-const hasStagedChanges = (ui) => {
+const hasStagedChanges = async (ui) => {
   const repo = ui.repo;
   if (repo.hasStaged) return repo.hasStaged(ui.top);
   return ui.items.some((item) => item.origin === 'staged');
@@ -63,6 +60,7 @@ class CommitController {
 
   reset() {
     this.commits = [];
+    this.staged = false;
     this.dropName = '';
     this.dropSha = '';
     this.commitView = 'brief';
@@ -89,10 +87,11 @@ class CommitController {
     return listedCommits(this.commits)[this.ui.nav.commitCursor] ?? null;
   }
 
-  loadCommits() {
+  async loadCommits() {
     const ui = this.ui;
     try {
-      this.commits = ui.repo.listCommits(ui.top);
+      const reads = [ui.repo.listCommits(ui.top), hasStagedChanges(ui)];
+      [this.commits, this.staged] = await Promise.all(reads);
       return true;
     } catch (error) {
       ui.status = error.message;
@@ -100,21 +99,28 @@ class CommitController {
     }
   }
 
-  refresh() {
-    if (!this.ui.repo.listCommits || !this.loadCommits()) return;
+  async refresh() {
+    if (!this.ui.repo.listCommits) return;
+    const loaded = await this.loadCommits();
+    if (!loaded) return;
     const last = listedCommits(this.commits).length - 1;
     const nav = this.ui.nav;
     if (nav.commitCursor > last) nav.commitCursor = Math.max(0, last);
   }
 
+  reload() {
+    const ui = this.ui;
+    return ui.ops.track(this.refresh().then(() => ui.paint()));
+  }
+
   refreshAfterWrite(extra = {}) {
-    this.refresh();
+    this.ui.ops.hold(this.refresh());
     this.ui.refreshFromRepo({ keepEmpty: true, ...extra });
   }
 
   indexForView() {
     const ui = this.ui;
-    if (hasStagedChanges(ui)) return 0;
+    if (this.staged) return 0;
     const list = listedCommits(this.commits);
     const want = `${ui.rev ?? ''}`;
     const short = `${ui.revShort ?? ''}`;
@@ -137,7 +143,13 @@ class CommitController {
       ui.status = 'read only';
       return;
     }
-    if (!this.loadCommits()) return;
+    ui.ops.hold(this.open());
+  }
+
+  async open() {
+    const ui = this.ui;
+    const loaded = await this.loadCommits();
+    if (!loaded) return;
     const nav = ui.nav;
     nav.commitCursor = this.indexForView();
     nav.pane = 'commits';
@@ -156,36 +168,48 @@ class CommitController {
     this.ui.status = '';
   }
 
-  messageFor(kind) {
+  async stagedFor(kind) {
+    if (isInPlaceCommit(kind)) return true;
+    return hasStagedChanges(this.ui);
+  }
+
+  async 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 (!ui.repo.lastMessage) return '';
+      const last = await ui.repo.lastMessage(ui.top);
+      return last ?? '';
     }
     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) ?? '';
+      const message = await ui.repo.commitMessage(ui.top, entry.sha);
+      return message ?? '';
     }
     ui.nav.commitCursor = 0;
     return '';
   }
 
   start(kind) {
+    this.ui.ops.hold(this.compose(kind));
+  }
+
+  async compose(kind) {
     const ui = this.ui;
     const composer = ui.composer;
-    if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+    const staged = await this.stagedFor(kind);
+    if (!staged) {
       ui.mode = 'review';
       composer.commitKind = null;
       ui.status = 'nothing to commit';
       return;
     }
-    let text = this.messageFor(kind);
+    let text = await this.messageFor(kind);
     if (text === null) return;
     composer.commitBody = '';
     if (isInPlaceCommit(kind) && this.brief) {
@@ -200,19 +224,74 @@ class CommitController {
     editor.cursor = lineEnd < 0 ? editor.text.length : lineEnd;
   }
 
-  onCommit() {
-    if (this.ui.nav.pane !== 'commits') return void this.show();
-    if (!this.canCommit()) return;
+  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';
+  }
+
+  chooseCommit(kind) {
+    this.ui.mode = 'review';
+    if (kind === 'update') return void this.onUpdate();
+    if (kind === 'amend') {
+      this.onAmend();
+      return;
+    }
+    if (kind === 'fixup') {
+      this.onFixup();
+      return;
+    }
     this.start('commit');
   }
 
+  onUpdate() {
+    if (!this.canWrite()) return;
+    const entry = this.selected();
+    if (!entry || !entry.sha) return;
+    this.ui.ops.hold(this.update(entry));
+  }
+
+  async update(entry) {
+    const staged = await hasStagedChanges(this.ui);
+    if (!staged) {
+      this.ui.status = 'nothing to commit';
+      return;
+    }
+    if (!this.ui.repo.updateCommit) {
+      this.ui.status = 'read only';
+      return;
+    }
+    const after = (extra) => this.refreshAfterWrite(extra);
+    this.ui.ops.runWrite(
+      'updateCommit',
+      [entry.sha],
+      'updating',
+      'updated',
+      after,
+    );
+  }
+
+  cancelCommitChoice() {
+    this.ui.mode = 'review';
+  }
+
+  onCommit() {
+    if (this.ui.nav.pane === 'commits') return;
+    this.show();
+  }
+
   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.onCommit();
+    if (entry.pending && !viewingCommit) return void this.onInsert();
     const sha = entry.pending ? '' : entry.sha || '';
     ui.rev = sha;
     ui.revShort = sha ? entry.shortSha || '' : '';
@@ -260,9 +339,12 @@ class CommitController {
     );
   }
 
-  runAsync(kind, done, run) {
+  submit(kind, done, run, settle = null) {
     this.ui.composer.closeCompose();
-    const after = () => this.refreshAfterWrite({ doneStatus: done });
+    const after = () => {
+      if (settle) settle();
+      this.refreshAfterWrite({ doneStatus: done });
+    };
     this.ui.ops.runBusy(kind, done, run, after);
   }
 
@@ -274,20 +356,8 @@ class CommitController {
       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();
-    this.refreshAfterWrite();
-    if (!ui.status) ui.status = done;
+    const run = (top) => ui.repo.reword(top, entry.sha, message);
+    this.submit('rewording', done, run);
   }
 
   finishGitCommit() {
@@ -303,28 +373,22 @@ class CommitController {
       ui.status = 'empty commit message';
       return;
     }
-    if (!isInPlaceCommit(kind) && !hasStagedChanges(ui)) {
+    ui.ops.hold(this.send(kind, message));
+  }
+
+  async send(kind, message) {
+    const ui = this.ui;
+    const staged = await this.stagedFor(kind);
+    if (!staged) {
       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.collection.clearDismissed();
-    this.refreshAfterWrite();
-    if (!ui.done && !ui.pendingExtras) ui.status = done;
+    const run = (top) => ui.repo.commit(top, kind, message);
+    const settle = () => ui.collection.clearDismissed();
+    this.submit('committing', done, run, settle);
   }
 
   onDropCommit() {
@@ -364,6 +428,8 @@ class CommitController {
     this.commitView = this.brief ? 'full' : 'brief';
     this.ui.nav.listScroll = 0;
     this.ui.status = this.commitView;
+    const root = this.ui.top || this.ui.cwd;
+    saveUiPrefs(root, { commitView: this.commitView });
   }
 }