reslop 0.1.8 → 0.2.0

package/lib/session/commit.js

@@ -1,6 +1,8 @@
 'use strict';
 
-const { isReadOnlyOrigin } = require('./origins.js');
+const { stateView } = require('./accessors.js');
+
+const { isReadOnlyOrigin } = require('../files.js');
 const { pickRepoWrite } = require('./ops.js');
 
 const COMMIT_STATUS = {
@@ -9,114 +11,267 @@ const COMMIT_STATUS = {
   fixup: 'fixup',
 };
 
-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 onCommit = (options) => {
-  if (!canCommit(options)) return;
-  options.setMode('confirmCommit');
-  options.setStatus('');
+const selectedCommit = (api) => {
+  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.ui.nav;
+  if (nav.commitCursor > last) nav.commitCursor = Math.max(0, last);
+};
+
+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;
+  }
+  clampCommitCursor(api);
 };
 
-const cancelCommit = (options) => {
-  options.setMode('review');
-  options.composer.state.commitKind = null;
-  options.setStatus('');
+const refreshAfterWrite = (api, extra = {}) => {
+  refreshCommitList(api);
+  api.ui.refreshFromRepo({ keepEmpty: true, ...extra });
 };
 
-const startGitCommit = (options, kind) => {
-  if (kind !== 'amend' && !hasStagedChanges(options)) {
-    options.setMode('review');
-    options.composer.state.commitKind = null;
-    options.setStatus('nothing to commit');
+const showCommits = (api) => {
+  if (api.ui.mode === 'compose') return;
+  if (!canCommit(api.ui)) return;
+  const repo = api.ui.repo;
+  if (!repo.listCommits) {
+    api.ui.status = 'read only';
     return;
   }
-  options.composer.state.commitKind = kind;
+  try {
+    api.state.commits = repo.listCommits(api.ui.top);
+  } catch (error) {
+    api.ui.status = error.message;
+    return;
+  }
+  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.ui.status = 'nothing to review';
+    return;
+  }
+  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 = '';
+};
+
+const startGitCommit = (api, kind) => {
+  const ui = api.ui;
+  if (kind !== 'amend' && !hasStagedChanges(ui)) {
+    ui.mode = 'review';
+    ui.composer.state.commitKind = null;
+    ui.status = 'nothing to commit';
+    return;
+  }
+  ui.composer.state.commitKind = kind;
   let text = '';
-  if (kind === 'fixup') text = 'HEAD';
-  if (kind === 'amend' && options.repo().lastMessage) {
-    text = options.repo().lastMessage(options.top()) ?? '';
+  if (kind === 'fixup') {
+    const entry = selectedCommit(api);
+    text = entry ? entry.shortSha || entry.sha : 'HEAD';
   }
-  options.composer.openCompose('commit', text);
+  if (kind === 'amend' && ui.repo.lastMessage) {
+    text = ui.repo.lastMessage(ui.top) ?? '';
+  }
+  ui.composer.openCompose('commit', text);
+};
+
+const onCommit = (api) => {
+  if (api.ui.nav.pane !== 'commits') return void showCommits(api);
+  if (!canCommit(api.ui)) return;
+  startGitCommit(api, 'commit');
+};
+
+const onAmend = (api) => {
+  if (api.ui.nav.pane !== 'commits') return;
+  if (!canCommit(api.ui)) return;
+  startGitCommit(api, 'amend');
+};
+
+const onFixup = (api) => {
+  if (api.ui.nav.pane !== 'commits') return;
+  if (!canCommit(api.ui)) return;
+  startGitCommit(api, 'fixup');
+};
+
+const cancelCommit = (api) => {
+  api.ui.mode = 'review';
+  api.ui.composer.state.commitKind = null;
+  api.ui.status = '';
 };
 
-const finishAsyncCommit = (options, kind, message, done, write) => {
-  const composer = options.composer;
-  composer.closeCompose();
+const finishAsyncCommit = (api, kind, message, done, write) => {
+  const ui = api.ui;
+  ui.composer.closeCompose();
   const run = (top) => write(top, kind, message);
-  const after = () => {
-    options.collection.clearDismissed();
-    options.refreshFromRepo({ doneStatus: done });
-  };
-  return void options.runner.runBusy('committing', done, run, after);
+  const after = () => refreshAfterWrite(api, { doneStatus: done });
+  return void ui.ops.runBusy('committing', done, run, after);
 };
 
-const finishSyncCommit = (options, kind, message, done) => {
+const finishSyncCommit = (api, kind, message, done) => {
+  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();
-  options.refreshFromRepo();
-  if (!options.isDone() && !options.pendingExtras()) {
-    options.setStatus(done);
+  ui.composer.closeCompose();
+  ui.collection.clearDismissed();
+  refreshAfterWrite(api);
+  if (!ui.done && !ui.pendingExtras) {
+    ui.status = done;
   }
 };
 
-const finishGitCommit = (options) => {
-  const kind = options.composer.state.commitKind;
-  const editor = options.composer.state.editor;
+const finishGitCommit = (api) => {
+  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');
+    ui.status = 'empty commit message';
     return;
   }
-  if (kind !== 'amend' && !hasStagedChanges(options)) {
-    options.composer.closeCompose();
-    options.setStatus('nothing to commit');
+  if (kind !== 'amend' && !hasStagedChanges(ui)) {
+    ui.composer.closeCompose();
+    ui.status = 'nothing to commit';
     return;
   }
   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(options, kind, message, done, picked.write);
+    return void finishAsyncCommit(api, kind, message, done, picked.write);
+  }
+  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 dropAsync = (api, sha, done, write) => {
+  const run = (top) => write(top, sha);
+  const after = () => refreshAfterWrite(api, { doneStatus: done });
+  return void api.ui.ops.runBusy('dropping', done, run, after);
+};
+
+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;
   }
-  finishSyncCommit(options, kind, message, done);
+  const uiOpen = api.ui.uiOpen;
+  const picked = pickRepoWrite(repo, 'dropCommit', uiOpen);
+  if (picked.async) {
+    return void dropAsync(api, sha, done, picked.write);
+  }
+  const ok = api.ui.ops.runRepo(done, (top) => {
+    repo.dropCommit(top, sha);
+  });
+  if (!ok) return;
+  refreshAfterWrite(api);
+  if (!api.ui.status) api.ui.status = done;
+};
+
+const reset = (state) => {
+  state.commits = [];
+  state.dropName = '';
+  state.dropSha = '';
 };
 
-const createCommitController = (options) => ({
-  canCommit: () => canCommit(options),
-  onCommit: () => onCommit(options),
-  cancelCommit: () => cancelCommit(options),
-  startGitCommit: (kind) => startGitCommit(options, kind),
-  finishGitCommit: () => finishGitCommit(options),
-});
+const createCommitController = (ui) => {
+  const state = {
+    commits: [],
+    dropName: '',
+    dropSha: '',
+  };
+  const api = { ui, state };
+  return stateView(
+    state,
+    {
+      reset: () => reset(state),
+      canCommit: () => canCommit(ui),
+      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),
+      refresh: () => refreshCommitList(api),
+      onDropCommit: () => onDropCommit(api),
+      cancelDropCommit: () => cancelDropCommit(api),
+      confirmDropCommit: () => confirmDropCommit(api),
+    },
+    ['commits', 'dropName'],
+  );
+};
 
 module.exports = {
   COMMIT_STATUS,

package/lib/session/compose.js

@@ -2,19 +2,19 @@
 
 const wrap = require('../wrap.js');
 const { cursorInWrap, wrapDoc } = wrap;
-const render = require('../render.js');
+const render = require('../render/render.js');
 const { noteInnerWidth, codeInnerWidth, todoBodyWidth } = render;
 const { Editor } = require('../editor.js');
 const files = require('../files.js');
-const { itemPath, isTodoItem } = files;
-const { blockAddText } = require('../diff.js');
+const { itemPath, isTodoItem, listPath, isReadOnlyOrigin } = files;
+const { blockAddText } = require('../diff/diff.js');
 const items = require('./items.js');
-const { itemFeedKey, canEditCode } = items;
-const { isReadOnlyOrigin } = require('./origins.js');
+const { itemFeedKey, canEditCode, blockLinesKey } = items;
 const review = require('../review.js');
 const { setFeedback, setCode, checkLabel, rememberTemplate } = review;
 const { createTemplatePick } = require('./templates.js');
 const { createTodoCompose } = require('./todos.js');
+const unit = require('./unit.js');
 
 const COMPOSE_EDITS = ['backspace', 'delete', 'ctrl-z', 'ctrl-y'];
 const COMPOSE_LEAVE = ['next', 'prev', 'todo'];
@@ -36,6 +36,14 @@ const KIND = {
     command: null,
     view: 'code',
   },
+  file: {
+    enter: 'newline',
+    tab: 'insert-tab',
+    escape: 'save',
+    move: 'code',
+    command: null,
+    view: 'code',
+  },
   todo: {
     enter: 'edit-next',
     tab: 'template',
@@ -72,6 +80,7 @@ const initialState = () => ({
   templateFocus: false,
   blinkOn: true,
   fileDirty: false,
+  fileEditRows: null,
 });
 
 const reset = (state) => {
@@ -91,6 +100,18 @@ const tickBlink = (api) => {
 
 const viewSize = (api) => api.ui.lastSize ?? api.ui.getSize();
 
+const followFileEdit = (api) => {
+  if (api.state.composeKind !== 'file') return;
+  const text = api.state.editor ? api.state.editor.text : null;
+  const rows = unit.linesFor(
+    api.ui,
+    api.nav.reviewPath,
+    text,
+    api.state.fileEditRows,
+  );
+  unit.followFileCursor(api.nav, api.state.editor, api.ui.lastFrame, rows);
+};
+
 const afterClose = (api) => {
   api.ui.clampIndex();
   api.ui.syncReviewPath();
@@ -121,6 +142,7 @@ const closeCompose = (api) => {
   state.composeBaseline = '';
   state.templateIndex = -1;
   state.templateFocus = false;
+  state.fileEditRows = null;
   afterClose(api);
 };
 
@@ -167,8 +189,7 @@ const saveCodeNote = (api, item, text) => {
   const key = itemFeedKey(item);
   const note = itemNote(item, text);
   if (text === original) {
-    setCode(notes, key, { ...note, clear: true });
-    return;
+    return void setCode(notes, key, { ...note, clear: true });
   }
   setCode(notes, key, note);
 };
@@ -198,6 +219,85 @@ const commitCode = (api, text) => {
   return true;
 };
 
+const saveUnitFile = (api, text) => {
+  const rel = api.nav.reviewPath;
+  const repo = api.ui.repo;
+  if (!rel || !repo || typeof repo.writeFile !== 'function') return true;
+  const caps = api.ui.capabilities;
+  if (!caps || caps.changes !== true) {
+    api.ui.status = 'read only';
+    return false;
+  }
+  try {
+    repo.writeFile(api.ui.top, rel, text);
+  } catch (error) {
+    api.ui.status = error.message;
+    return false;
+  }
+  if (typeof api.ui.ignoreWatch === 'function') api.ui.ignoreWatch();
+  api.state.composeBaseline = text;
+  api.state.fileDirty = true;
+  return true;
+};
+
+const snapshotPathKeys = (list, rel) => {
+  const keys = new Set();
+  for (const item of list) {
+    if (listPath(item) !== rel) continue;
+    keys.add(blockLinesKey(item));
+  }
+  return keys;
+};
+
+const stageNewFileHunks = (api, rel, beforeKeys) => {
+  const repo = api.ui.repo;
+  if (!rel || !repo || typeof repo.add !== 'function') return 0;
+  const caps = api.ui.capabilities;
+  if (!caps || caps.changes !== true) return 0;
+  const list = api.ui.items ?? [];
+  let staged = 0;
+  for (const item of list) {
+    if (listPath(item) !== rel) continue;
+    if (isReadOnlyOrigin(item.origin)) continue;
+    if (item.origin === 'staged') continue;
+    if (beforeKeys.has(blockLinesKey(item))) continue;
+    try {
+      repo.add(api.ui.top, item);
+    } catch (error) {
+      api.ui.status = error.message;
+      return staged;
+    }
+    if (api.ui.collection && api.ui.collection.keepOrigin) {
+      api.ui.collection.keepOrigin(item, 'staged');
+    }
+    if (typeof api.ui.ignoreWatch === 'function') api.ui.ignoreWatch();
+    staged += 1;
+  }
+  return staged;
+};
+
+const saveFileCompose = (api) => {
+  const rel = api.nav.reviewPath;
+  const beforeKeys = snapshotPathKeys(api.ui.items ?? [], rel);
+  if (api.state.editor) {
+    api.nav.unitLine = api.state.editor.linePos().line;
+  }
+  const result = saveUnitFile(api, api.state.editor.text);
+  if (result === false) return { kind: 'error' };
+  const reload = api.state.fileDirty === true;
+  api.ui.flushReview();
+  closeCompose(api);
+  if (!reload || typeof api.ui.reloadAfterChange !== 'function') {
+    api.ui.status = 'saved';
+    return { kind: 'saved' };
+  }
+  api.ui.reloadAfterChange(() => {
+    const n = stageNewFileHunks(api, rel, beforeKeys);
+    api.ui.status = n > 0 ? 'staged' : 'saved';
+  });
+  return { kind: 'saved' };
+};
+
 const commitCompose = (api) => {
   const { state } = api;
   if (!state.composeKind || !state.editor) return true;
@@ -211,6 +311,7 @@ const commitCompose = (api) => {
     return true;
   }
   if (state.composeKind === 'code') return commitCode(api, text);
+  if (state.composeKind === 'file') return saveUnitFile(api, text);
   return true;
 };
 
@@ -219,6 +320,7 @@ const saveCompose = (api, extra) => {
   const spec = KIND[api.state.composeKind];
   if (spec && spec.command) return { kind: spec.command };
   const kind = api.state.composeKind;
+  if (kind === 'file') return saveFileCompose(api);
   const baseline = api.state.composeBaseline;
   const result = commitCompose(api);
   if (result === false) return { kind: 'error' };
@@ -243,6 +345,10 @@ const autosave = (api) => {
   const { state } = api;
   const spec = KIND[state.composeKind];
   const text = state.editor ? state.editor.text : '';
+  if (state.composeKind === 'file' && state.editor) {
+    if (text === state.composeBaseline) return;
+    return void saveUnitFile(api, text);
+  }
   const editingCode = state.composeKind === 'code';
   const composing = state.composeKind !== null;
   const reviewKind = composing && (!spec || !spec.command);
@@ -267,9 +373,10 @@ const composeView = (api) => {
 };
 
 const liveCodeText = (api) => {
+  const { state } = api;
+  if (state.composeKind === 'file' && state.editor) return state.editor.text;
   const item = api.ui.current();
   if (!canEditCode(item)) return null;
-  const { state } = api;
   if (state.composeKind === 'code' && state.editor) return state.editor.text;
   if (writesCodeFile(api, item)) return null;
   const notes = api.review.store;
@@ -282,7 +389,8 @@ const liveCodeText = (api) => {
 const codeOverlayView = (api) => {
   const text = liveCodeText(api);
   if (text === null) return null;
-  const editing = api.state.composeKind === 'code';
+  const editing =
+    api.state.composeKind === 'code' || api.state.composeKind === 'file';
   const editor = api.state.editor;
   const cursor = editing && editor ? editor.cursor : null;
   return { text, keepEmpty: editing, cursor };
@@ -351,14 +459,12 @@ const moveComposeLine = (api, delta) => {
   if (move === 'todo') {
     const size = viewSize(api);
     const inner = todoBodyWidth(size.width);
-    api.todos.moveTodoCompose(delta, inner);
-    return;
+    return void api.todos.moveTodoCompose(delta, inner);
   }
   if (move === 'code') {
     const size = viewSize(api);
     const inner = codeInnerWidth(size.width, api.ui.layout);
-    api.state.editor.moveLine(delta, inner);
-    return;
+    return void api.state.editor.moveLine(delta, inner);
   }
   moveNoteLine(api, delta);
 };
@@ -410,7 +516,26 @@ const onFeedback = (api) => {
   openCompose(api, 'feedback', text);
 };
 
+const onUnitEdit = (api) => {
+  const rel = api.nav.reviewPath;
+  if (!rel) {
+    api.ui.status = 'not a diff block';
+    return;
+  }
+  const caps = api.ui.capabilities;
+  if (!caps || caps.changes !== true) {
+    api.ui.status = 'read only';
+    return;
+  }
+  const at = unit.editCursor(api.ui);
+  openCompose(api, 'file', at.text);
+  api.state.fileEditRows = at.rows ?? null;
+  api.state.editor.cursor = Math.min(at.cursor, at.text.length);
+  followFileEdit(api);
+};
+
 const onCode = (api) => {
+  if (api.nav.pane === 'unit') return void onUnitEdit(api);
   if (api.nav.pane === 'files') {
     api.ui.status = 'not a diff block';
     return;
@@ -438,6 +563,7 @@ const enterCompose = (api) => {
   if (spec && spec.enter === 'newline') {
     state.editor.insert('\n');
     resetBlink(api);
+    followFileEdit(api);
     return null;
   }
   if (spec && spec.enter === 'edit-next') {
@@ -484,6 +610,7 @@ const handleKey = (api, key) => {
     const result = special(api);
     if (COMPOSE_EDITS.includes(key)) api.templates.clearTemplatePick();
     resetBlink(api);
+    followFileEdit(api);
     return result ?? null;
   }
   if (!key.length) return null;
@@ -492,10 +619,22 @@ const handleKey = (api, key) => {
     api.templates.clearTemplatePick();
     api.state.editor.insert(key);
     resetBlink(api);
+    followFileEdit(api);
   }
   return null;
 };
 
+const applyDiskText = (api, text) => {
+  if (api.state.composeKind !== 'file' || !api.state.editor) return;
+  if (text === api.state.editor.text) return;
+  const cursor = api.state.editor.cursor;
+  api.state.editor.text = text;
+  api.state.editor.cursor = Math.min(cursor, text.length);
+  api.state.composeBaseline = text;
+  api.state.fileEditRows = unit.linesFor(api.ui, api.nav.reviewPath, null);
+  followFileEdit(api);
+};
+
 const composerMethods = (api) => ({
   reset: () => reset(api.state),
   openCompose: (kind, text, todoId) => openCompose(api, kind, text, todoId),
@@ -511,6 +650,12 @@ const composerMethods = (api) => ({
   onFeedback: () => onFeedback(api),
   onCode: () => onCode(api),
   handleKey: (key) => handleKey(api, key),
+  liveFileText: () => {
+    if (api.state.composeKind !== 'file' || !api.state.editor) return null;
+    return api.state.editor.text;
+  },
+  fileEditRows: () => api.state.fileEditRows,
+  applyDiskText: (text) => applyDiskText(api, text),
 });
 
 const createComposer = ({ nav, review, ui, restartBlink }) => {