reslop 0.2.6 → 0.3.0

package/lib/session/compose.js

@@ -1,29 +1,24 @@
 'use strict';
 
-const wrap = require('../wrap.js');
-const { cursorInWrap, wrapDoc } = wrap;
+const { cursorInWrap, wrapDoc } = require('../term/wrap.js');
 const render = require('../render/render.js');
-const { noteInnerWidth, codeInnerWidth, todoBodyWidth } = render;
-const commits = require('../render/commits.js');
-const { commitMessageWidth } = commits;
-const commit = require('./commit.js');
-const { listedCommits } = commit;
-const editor = require('../editor.js');
-const { Editor } = editor;
-const files = require('../files.js');
-const { itemPath, isTaskItem, listPath, isReadOnlyOrigin } = files;
-const diff = require('../diff/diff.js');
-const { blockAddText } = diff;
-const items = require('./items.js');
-const { itemFeedKey, canEditCode } = items;
-const review = require('../review.js');
-const { setFeedback, setCode, checkLabel, rememberTemplate } = review;
-const templates = require('./templates.js');
-const { TemplatePick } = templates;
-const tasks = require('./tasks.js');
-const { TaskPage } = tasks;
+const { noteInnerWidth, codeInnerWidth, todoBodyWidth, activeDigits } = render;
+const { commitMessageWidth } = require('../render/commits.js');
+const { listedCommits } = require('./commit.js');
+const { Editor } = require('../input/editor.js');
+const { isTextKey } = require('../input/keys.js');
+const files = require('../common/files.js');
+const { itemPath, isTaskItem, isTasksEntry, listPath } = files;
+const { isReadOnlyOrigin } = files;
+const { blockAddText } = require('../diff/diff.js');
+const { itemFeedKey, canEditCode } = require('./items.js');
+const review = require('../review/review.js');
+const { checkLabel } = review;
+const { TemplatePick } = require('./templates.js');
+const { TaskPage } = require('./tasks.js');
 const unit = require('./unit.js');
-const clipboard = require('../clipboard.js');
+const clipboard = require('../term/clipboard.js');
+const { EDIT_OP, copyLine, cutLine } = require('../input/line-edit.js');
 
 const COMPOSE_EDITS = ['backspace', 'delete', 'ctrl-z', 'ctrl-y'];
 const COMPOSE_CLIP = ['ctrl-x', 'ctrl-v'];
@@ -37,10 +32,11 @@ const KIND = {
   commit: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
   branch: { enter: 'save', tab: 'template', escape: 'cancel', move: 'note' },
   npm: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
+  package: { enter: 'save', tab: 'insert-tab', escape: 'cancel', move: 'note' },
 };
 
-const COMMAND_KINDS = ['commit', 'branch', 'npm'];
-const NOTE_VIEWS = ['feedback', 'commit', 'branch', 'npm'];
+const COMMAND_KINDS = ['commit', 'branch', 'npm', 'package'];
+const NOTE_VIEWS = ['feedback', 'commit', 'branch', 'npm', 'package'];
 
 const itemNote = (item, text) => {
   const hunk = item.hunk;
@@ -76,17 +72,13 @@ const blankTail = (text) => {
   return count;
 };
 
+const EDITOR_KEYS = {};
+for (const key of Object.keys(EDIT_OP)) {
+  EDITOR_KEYS[key] = (c) => EDIT_OP[key](c.editor);
+}
+
 const COMPOSE_SPECIAL = {
-  backspace: (c) => c.editor.backspace(),
-  delete: (c) => c.editor.delete(),
-  left: (c) => c.editor.move(-1),
-  right: (c) => c.editor.move(1),
-  'shift-left': (c) => c.editor.move(-1, true),
-  'shift-right': (c) => c.editor.move(1, true),
-  'ctrl-left': (c) => c.editor.moveWord(-1),
-  'ctrl-right': (c) => c.editor.moveWord(1),
-  'ctrl-shift-left': (c) => c.editor.moveWord(-1, true),
-  'ctrl-shift-right': (c) => c.editor.moveWord(1, true),
+  ...EDITOR_KEYS,
   up: (c) => c.moveLine(-1),
   down: (c) => c.moveLine(1),
   'shift-up': (c) => c.moveLine(-1, true),
@@ -116,7 +108,9 @@ class Composer {
   }
 
   reset() {
+    this.tasks.closePlanMenu();
     this.fileDirty = false;
+    this.saving = false;
     this.clear();
   }
 
@@ -126,6 +120,7 @@ class Composer {
     this.commitKind = null;
     this.commitBody = '';
     this.composeTaskId = null;
+    this.composeQuoteKey = null;
     this.composeBaseline = '';
     this.templateIndex = -1;
     this.templateFocus = false;
@@ -155,7 +150,8 @@ class Composer {
     if (kind !== 'code' && kind !== 'file') return;
     if (!this.editor) return;
     const width = this.viewSize().width;
-    this.editor.reveal(codeInnerWidth(width, this.ui.layout));
+    const digits = activeDigits(this.ui);
+    this.editor.reveal(codeInnerWidth(width, this.ui.layout, digits));
   }
 
   followFileEdit() {
@@ -171,6 +167,7 @@ class Composer {
     this.ui.mode = 'compose';
     this.composeKind = kind;
     this.composeTaskId = taskId;
+    this.composeQuoteKey = null;
     this.composeBaseline = text;
     this.fileOpened = kind === 'file' ? text : '';
     this.editor = new Editor(text);
@@ -180,6 +177,11 @@ class Composer {
     this.ui.nav.clearSelection();
   }
 
+  openQuote(key, text) {
+    this.openCompose('tasks', text, null);
+    this.composeQuoteKey = key;
+  }
+
   closeCompose() {
     const ui = this.ui;
     ui.mode = 'review';
@@ -203,7 +205,7 @@ class Composer {
   commitFeedback(text) {
     const item = this.ui.current();
     if (!item || isTaskItem(item)) return;
-    setFeedback(this.notes, itemFeedKey(item), itemNote(item, text));
+    this.notes.setFeedback(itemFeedKey(item), itemNote(item, text));
   }
 
   dropCodeNote(item, text) {
@@ -211,34 +213,52 @@ class Composer {
     if (!notes) return;
     const key = itemFeedKey(item);
     if (!notes.code.has(key)) return;
-    setCode(notes, key, { ...itemNote(item, text), clear: true });
+    notes.setCode(key, { ...itemNote(item, text), clear: true });
+  }
+
+  // Edits that land in the worktree or index, not in the review notes
+  writesDisk() {
+    const kind = this.composeKind;
+    if (!this.editor) return false;
+    if (kind === 'file') return true;
+    return kind === 'code' && this.writesCodeFile(this.ui.current());
   }
 
   commitCode(text) {
+    const item = this.ui.current();
+    if (!canEditCode(item) || this.writesCodeFile(item)) return;
+    const note = itemNote(item, text);
+    const clear = text === blockAddText(item.hunk, item.blockId);
+    this.notes.setCode(itemFeedKey(item), clear ? { ...note, clear } : note);
+  }
+
+  async write(action) {
     const ui = this.ui;
-    const item = ui.current();
-    if (!canEditCode(item)) return true;
-    const original = blockAddText(item.hunk, item.blockId);
-    if (!this.writesCodeFile(item)) {
-      const note = itemNote(item, text);
-      const clear = text === original;
-      setCode(this.notes, itemFeedKey(item), clear ? { ...note, clear } : note);
-      return true;
+    ui.ignoreWatch();
+    try {
+      await ui.ops.exclusive(action);
+    } catch (error) {
+      ui.status = error.message;
+      return false;
     }
-    if (text !== original) {
-      try {
-        ui.repo.edit(ui.top, item, text);
-      } catch (error) {
-        ui.status = error.message;
-        return false;
-      }
+    ui.ignoreWatch();
+    return true;
+  }
+
+  async writeCode(text) {
+    const ui = this.ui;
+    const item = ui.current();
+    if (text !== blockAddText(item.hunk, item.blockId)) {
+      const edit = (top) => ui.repo.edit(top, item, text);
+      const written = await this.write(edit);
+      if (!written) return false;
       this.fileDirty = true;
     }
     this.dropCodeNote(item, text);
     return true;
   }
 
-  saveUnitFile(text) {
+  async saveUnitFile(text) {
     const ui = this.ui;
     const rel = ui.nav.reviewPath;
     if (!rel || !ui.repo.writeFile) return true;
@@ -246,48 +266,37 @@ class Composer {
       ui.status = 'read only';
       return false;
     }
-    try {
-      ui.repo.writeFile(ui.top, rel, text);
-    } catch (error) {
-      ui.status = error.message;
-      return false;
-    }
-    ui.ignoreWatch();
+    const save = (top) => ui.repo.writeFile(top, rel, text);
+    const written = await this.write(save);
+    if (!written) return false;
+    ui.reads.keepText(rel, text);
     this.composeBaseline = text;
     this.fileDirty = true;
     return true;
   }
 
-  stageEditedFile(rel) {
+  stageItems(rel) {
     const ui = this.ui;
     const repo = ui.repo;
-    if (!rel || !this.canChange()) return false;
-    if (repo.stagePath) {
-      try {
-        repo.stagePath(ui.top, rel);
-      } catch (error) {
-        ui.status = error.message;
-        return false;
-      }
-      ui.ignoreWatch();
-      return true;
-    }
-    if (!repo.add) return false;
-    let staged = 0;
-    for (const item of ui.items) {
-      if (listPath(item) !== rel) continue;
-      if (isReadOnlyOrigin(item.origin) || item.origin === 'staged') continue;
-      try {
-        repo.add(ui.top, item);
-      } catch (error) {
-        ui.status = error.message;
-        return staged > 0;
-      }
-      ui.collection.keepOrigin(item, 'staged');
-      staged += 1;
-    }
-    if (staged) ui.ignoreWatch();
-    return staged > 0;
+    if (!repo.add) return;
+    const targets = ui.items.filter((item) => {
+      if (listPath(item) !== rel || isReadOnlyOrigin(item.origin)) return false;
+      return item.origin !== 'staged';
+    });
+    if (!targets.length) return;
+    for (const item of targets) ui.collection.keepOrigin(item, 'staged');
+    ui.ignoreWatch();
+    const write = async () => {
+      for (const item of targets) await ui.ops.add(item);
+    };
+    ui.ops.enqueueLazy({ kind: 'staged', done: '', reload: false, write });
+  }
+
+  async stageEditedFile(rel) {
+    const repo = this.ui.repo;
+    if (!rel || !this.canChange()) return;
+    if (!repo.stagePath) return void this.stageItems(rel);
+    await this.write((top) => repo.stagePath(top, rel));
   }
 
   finishSave(reload, doneStatus) {
@@ -298,84 +307,112 @@ class Composer {
       if (!ui.status) ui.status = doneStatus;
       return;
     }
+    this.fileDirty = false;
     ui.reloadAfterChange(() => {
       if (!ui.status) ui.status = doneStatus;
     });
   }
 
-  saveFileCompose() {
+  // Closes the editor after a note or a block edit; reloads if a file changed
+  finishNote(doneStatus) {
+    const ui = this.ui;
+    if (this.fileDirty === true) return void this.finishSave(true, doneStatus);
+    ui.flushReview();
+    this.closeCompose();
+    ui.status = doneStatus;
+  }
+
+  async saveFile() {
     const rel = this.ui.nav.reviewPath;
     const opened = this.fileOpened;
-    const text = this.editor ? this.editor.text : '';
-    if (this.editor) this.ui.nav.unitLine = this.editor.linePos().line;
-    if (!this.saveUnitFile(text)) return { kind: 'error' };
+    const text = this.editor.text;
+    this.ui.nav.unitLine = this.editor.linePos().line;
+    const saved = await this.saveUnitFile(text);
+    if (!saved) return false;
     const changed = text !== opened;
     const reload = this.fileDirty === true;
-    if (changed) this.stageEditedFile(rel);
+    if (changed) await this.stageEditedFile(rel);
     this.finishSave(reload, changed ? 'staged' : 'saved');
-    return { kind: 'saved' };
+    return true;
+  }
+
+  async saveCode() {
+    const ui = this.ui;
+    const item = ui.current();
+    const unstaged = item.origin !== 'staged';
+    const rel = itemPath(item);
+    const saved = await this.writeCode(this.editor.text);
+    if (!saved) return false;
+    const staging = unstaged && this.fileDirty === true;
+    if (staging) await this.stageEditedFile(rel);
+    this.finishNote(staging ? 'staged' : 'saved');
+    return true;
+  }
+
+  saveEdit() {
+    return this.composeKind === 'file' ? this.saveFile() : this.saveCode();
+  }
+
+  // One save at a time; `after` runs once the edit is safely on disk
+  async saveToDisk(after) {
+    if (this.saving) return;
+    this.saving = true;
+    const settle = () => {
+      this.saving = false;
+    };
+    const saved = await this.saveEdit().finally(settle);
+    if (saved && after) after();
+  }
+
+  // Leaves the editor whether or not the edit could be written
+  async writeAndClose() {
+    const text = this.editor.text;
+    if (this.composeKind === 'file') await this.saveUnitFile(text);
+    else await this.writeCode(text);
+    this.closeCompose();
   }
 
   commitCompose() {
     const kind = this.composeKind;
-    if (!kind || !this.editor) return true;
+    if (!kind || !this.editor) return;
     const text = this.editor.text;
-    if (kind === 'feedback') {
-      if (this.notes) this.commitFeedback(text);
-      return true;
-    }
-    if (kind === 'tasks') {
-      this.tasks.commitTask(text);
-      return true;
-    }
-    if (kind === 'code') return this.commitCode(text);
-    if (kind === 'file') return this.saveUnitFile(text);
-    return true;
+    if (kind === 'feedback' && this.notes) this.commitFeedback(text);
+    if (kind === 'tasks') this.tasks.commitTask(text);
+    if (kind === 'code') this.commitCode(text);
   }
 
+  // Notes save at once. An edit to a file answers `saving` and finishes later
   saveCompose(opts = {}) {
     const ui = this.ui;
     const kind = this.composeKind;
     if (COMMAND_KINDS.includes(kind)) return { kind };
-    if (kind === 'file') return this.saveFileCompose();
-    const item = ui.current();
-    const shouldStage =
-      kind === 'code' && this.writesCodeFile(item) && item.origin !== 'staged';
-    const rel = itemPath(item);
+    if (this.writesDisk()) {
+      ui.ops.hold(this.saveToDisk(opts.after));
+      return { kind: 'saving' };
+    }
     const baseline = this.composeBaseline;
-    if (this.commitCompose() === false) return { kind: 'error' };
-    const reload = this.fileDirty === true;
+    this.commitCompose();
     if (kind === 'feedback' && this.notes) {
       const next = this.editor ? this.editor.text : '';
-      rememberTemplate(this.notes, baseline, next);
-    }
-    const staging = shouldStage && reload;
-    if (staging) this.stageEditedFile(rel);
-    const doneStatus = staging ? 'staged' : 'saved';
-    if (reload) {
-      this.finishSave(true, doneStatus);
-    } else {
-      ui.flushReview();
-      this.closeCompose();
-      ui.status = doneStatus;
+      this.notes.rememberTemplate(baseline, next);
     }
+    this.finishNote('saved');
     if (opts.editNext === true) this.tasks.editNextTask();
     return { kind: 'saved' };
   }
 
+  autosaveFile(text) {
+    if (this.saving || text === this.composeBaseline) return;
+    this.ui.ops.track(this.saveUnitFile(text));
+  }
+
   autosave() {
     const kind = this.composeKind;
     const text = this.editor ? this.editor.text : '';
-    if (kind === 'file' && this.editor) {
-      if (text === this.composeBaseline) return;
-      return void this.saveUnitFile(text);
-    }
-    const editingCode = kind === 'code';
+    if (kind === 'file' && this.editor) return void this.autosaveFile(text);
     const reviewKind = kind !== null && !COMMAND_KINDS.includes(kind);
-    const fileEdit = editingCode && this.writesCodeFile(this.ui.current());
-    if (reviewKind && !fileEdit && (editingCode || text.trim())) {
-      this.commitCompose();
-    }
+    const noted = reviewKind && !this.writesDisk();
+    if (noted && (kind === 'code' || text.trim())) this.commitCompose();
     if (this.notes && this.notes.dirty) this.ui.flushReview();
   }
 
@@ -536,6 +573,12 @@ class Composer {
       ui.status = 'read only';
       return;
     }
+    ui.ops.hold(this.editViewed());
+  }
+
+  async editViewed() {
+    const ui = this.ui;
+    await ui.reads.loadText(ui.nav.reviewPath);
     const at = unit.editCursor(ui);
     this.openCompose('file', at.text);
     this.fileEditRows = at.rows ?? null;
@@ -544,11 +587,24 @@ class Composer {
     this.followFileEdit();
   }
 
+  onFileEdit() {
+    const ui = this.ui;
+    const list = ui.fileList();
+    const entry = list[ui.nav.fileCursor];
+    if (!entry || isTasksEntry(entry)) {
+      ui.status = 'not a diff block';
+      return;
+    }
+    const edit = () => this.onUnitEdit();
+    ui.ops.hold(unit.showFile(ui, entry).then(edit));
+  }
+
   onCode() {
     const ui = this.ui;
+    if (ui.nav.pane === 'files') return void this.onFileEdit();
     if (ui.nav.pane === 'unit') return void this.onUnitEdit();
     const item = ui.current();
-    if (ui.nav.pane === 'files' || !canEditCode(item)) {
+    if (!canEditCode(item)) {
       ui.status = 'not a diff block';
       return;
     }
@@ -594,16 +650,11 @@ class Composer {
   }
 
   copy() {
-    const text = this.editor.selectedText();
-    if (!text) return;
-    const ok = clipboard.copyText(text, this.ui.stdout);
-    this.ui.status = ok ? 'copied' : 'copy failed';
+    copyLine(this.editor, this.ui);
   }
 
   cut() {
-    if (!this.editor.hasSelect()) return;
-    this.copy();
-    this.editor.removeSpan();
+    cutLine(this.editor, this.ui);
   }
 
   paste() {
@@ -631,10 +682,7 @@ class Composer {
       this.afterEdit();
       return result ?? null;
     }
-    if (!key.length || key.startsWith('ctrl-') || key.startsWith('alt-')) {
-      return null;
-    }
-    if (key.charCodeAt(0) >= 32) {
+    if (isTextKey(key)) {
       this.templates.clearTemplatePick();
       this.editor.insert(key);
       this.afterEdit();
@@ -645,12 +693,15 @@ class Composer {
   applyDiskText(text) {
     const editor = this.editor;
     if (this.composeKind !== 'file' || !editor) return;
-    if (text === editor.text) return;
+    // The baseline is the last text known on disk: no news, keep the typing
+    if (text === editor.text || text === this.composeBaseline) return;
     const cursor = editor.cursor;
     editor.text = text;
     editor.cursor = Math.min(cursor, text.length);
     editor.anchor = null;
     this.composeBaseline = text;
+    // An outside change is the new starting point, not an edit made here
+    this.fileOpened = text;
     this.fileEditRows = unit.linesFor(this.ui, this.ui.nav.reviewPath, null);
     this.syncCodeScroll();
     this.followFileEdit();