reslop 0.1.9 → 0.2.1

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 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,8 @@ const initialState = () => ({
   templateFocus: false,
   blinkOn: true,
   fileDirty: false,
+  fileEditRows: null,
+  fileOpened: '',
 });
 
 const reset = (state) => {
@@ -91,6 +101,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();
@@ -103,6 +125,7 @@ const openCompose = (api, kind, text, todoId) => {
   state.composeKind = kind;
   state.composeTodoId = todoId ?? null;
   state.composeBaseline = text;
+  state.fileOpened = kind === 'file' ? text : '';
   state.editor = new Editor(text);
   state.templateIndex = -1;
   state.templateFocus = false;
@@ -119,8 +142,10 @@ const closeCompose = (api) => {
   state.commitKind = null;
   state.composeTodoId = null;
   state.composeBaseline = '';
+  state.fileOpened = '';
   state.templateIndex = -1;
   state.templateFocus = false;
+  state.fileEditRows = null;
   afterClose(api);
 };
 
@@ -167,8 +192,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 +222,91 @@ 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 stageEditedFile = (api, rel) => {
+  if (!rel) return false;
+  const repo = api.ui.repo;
+  if (!repo) return false;
+  const caps = api.ui.capabilities;
+  if (!caps || caps.changes !== true) return false;
+  if (typeof repo.stagePath === 'function') {
+    try {
+      repo.stagePath(api.ui.top, rel);
+    } catch (error) {
+      api.ui.status = error.message;
+      return false;
+    }
+    if (typeof api.ui.ignoreWatch === 'function') api.ui.ignoreWatch();
+    return true;
+  }
+  if (typeof repo.add !== 'function') return false;
+  let staged = 0;
+  for (const item of api.ui.items ?? []) {
+    if (listPath(item) !== rel) continue;
+    if (isReadOnlyOrigin(item.origin)) continue;
+    if (item.origin === 'staged') continue;
+    try {
+      repo.add(api.ui.top, item);
+    } catch (error) {
+      api.ui.status = error.message;
+      return staged > 0;
+    }
+    if (api.ui.collection && api.ui.collection.keepOrigin) {
+      api.ui.collection.keepOrigin(item, 'staged');
+    }
+    staged += 1;
+  }
+  if (staged && typeof api.ui.ignoreWatch === 'function') {
+    api.ui.ignoreWatch();
+  }
+  return staged > 0;
+};
+
+const saveFileCompose = (api) => {
+  const rel = api.nav.reviewPath;
+  const opened = api.state.fileOpened;
+  const text = api.state.editor ? api.state.editor.text : '';
+  if (api.state.editor) {
+    api.nav.unitLine = api.state.editor.linePos().line;
+  }
+  const result = saveUnitFile(api, text);
+  if (result === false) return { kind: 'error' };
+  const changed = text !== opened;
+  const reload = api.state.fileDirty === true;
+  if (changed) stageEditedFile(api, rel);
+  api.ui.flushReview();
+  closeCompose(api);
+  const doneStatus = changed ? 'staged' : 'saved';
+  if (!reload || typeof api.ui.reloadAfterChange !== 'function') {
+    if (!api.ui.status) api.ui.status = doneStatus;
+    return { kind: 'saved' };
+  }
+  api.ui.reloadAfterChange(() => {
+    if (!api.ui.status) api.ui.status = doneStatus;
+  });
+  return { kind: 'saved' };
+};
+
 const commitCompose = (api) => {
   const { state } = api;
   if (!state.composeKind || !state.editor) return true;
@@ -211,6 +320,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 +329,14 @@ 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 item = api.ui.current ? api.ui.current() : null;
+  const shouldStage =
+    kind === 'code' &&
+    writesCodeFile(api, item) &&
+    item &&
+    item.origin !== 'staged';
+  const rel = itemPath(item);
   const baseline = api.state.composeBaseline;
   const result = commitCompose(api);
   if (result === false) return { kind: 'error' };
@@ -229,12 +347,17 @@ const saveCompose = (api, extra) => {
     const next = editor ? editor.text : '';
     if (notes) rememberTemplate(notes, baseline, next);
   }
+  if (shouldStage && reload) stageEditedFile(api, rel);
   api.ui.flushReview();
   closeCompose(api);
+  const doneStatus = shouldStage && reload ? 'staged' : 'saved';
   if (reload && typeof api.ui.reloadAfterChange === 'function') {
-    api.ui.reloadAfterChange();
+    api.ui.reloadAfterChange(() => {
+      if (!api.ui.status) api.ui.status = doneStatus;
+    });
+  } else {
+    api.ui.status = doneStatus;
   }
-  api.ui.status = 'saved';
   if (opts.editNext === true) api.todos.editNextTodo();
   return { kind: 'saved' };
 };
@@ -243,6 +366,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);
@@ -263,13 +390,14 @@ const composeView = (api) => {
   const kind = state.composeKind;
   const text = state.editor.text;
   const cursor = state.editor.cursor;
-  return { kind, text, cursor };
+  return { kind, text, cursor, commitKind: state.commitKind };
 };
 
 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 +410,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 +480,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 +537,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 +584,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 +631,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 +640,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 +671,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 }) => {

package/lib/session/dispatch.js

@@ -5,67 +5,92 @@ const { COMPOSE_LEAVE } = compose;
 const actions = require('./actions.js');
 const { CONFIRM_MODE, disabledActions, actionFromKey, applyConfirm } = actions;
 
-const createDispatcher = (options) => {
+const targetHasStaged = (session) => {
+  if (session.repo.hasStaged) return session.repo.hasStaged(session.top);
+  return session.items.some((item) => item.origin === 'staged');
+};
+
+const currentTarget = (ui) => {
+  if (ui.pane === 'files') return ui.fileCursorEntry();
+  if (ui.pane === 'branches') {
+    return ui.branches[ui.branchCursor];
+  }
+  if (ui.pane === 'commits') {
+    const entry = ui.commits.commits[ui.commitCursor];
+    const staged = targetHasStaged(ui);
+    if (!entry) return { canCommit: staged };
+    return { ...entry, canCommit: staged };
+  }
+  return ui.current();
+};
+
+const createDispatcher = (ui) => {
   const handlers = {
-    add: options.changeActions.onAdd,
-    unstage: options.changeActions.onUnstage,
-    revert: options.changeActions.onRevert,
-    next: options.onNext,
-    prev: options.onPrev,
-    layout: options.onLayout,
-    files: options.onFiles,
-    feedback: options.composer.onFeedback,
-    todo: options.composer.onTodo,
-    code: options.composer.onCode,
-    reload: options.onReload,
-    commit: options.commits.onCommit,
-    amend: options.commits.onAmend,
-    fixup: options.commits.onFixup,
-    branch: options.gitBranches.onBranch,
-    pull: options.gitBranches.onPull,
-    push: options.gitBranches.onPush,
-    newBranch: options.gitBranches.onNewBranch,
-    rebase: options.gitBranches.onRebaseBranch,
+    add: ui.changeActions.onAdd,
+    unstage: ui.changeActions.onUnstage,
+    revert: ui.changeActions.onRevert,
+    next: ui.filesPane.onNext,
+    prev: ui.filesPane.onPrev,
+    layout: ui.filesPane.onLayout,
+    theme: ui.filesPane.onTheme,
+    files: ui.filesPane.onFiles,
+    feedback: ui.composer.onFeedback,
+    todo: ui.composer.onTodo,
+    code: ui.composer.onCode,
+    reload: ui.lifecycle.onReload,
+    commit: ui.commits.onCommit,
+    amend: ui.commits.onAmend,
+    reword: ui.commits.onReword,
+    apply: ui.commits.onApply,
+    fixup: ui.commits.onFixup,
+    branch: ui.gitBranches.onBranch,
+    pull: ui.gitBranches.onPull,
+    push: ui.gitBranches.onPush,
+    newBranch: ui.gitBranches.onNewBranch,
+    rebase: ui.gitBranches.onRebaseBranch,
     drop: () => {
-      if (options.getPane() === 'commits') {
-        return void options.commits.onDropCommit();
+      if (ui.pane === 'commits') {
+        return void ui.commits.onDropCommit();
       }
-      options.gitBranches.onDropBranch();
+      ui.gitBranches.onDropBranch();
     },
-    open: options.onOpenFile,
-    removeTodo: options.composer.removeFocusedTodo,
-    quit: options.onQuit,
-    scrollUp: () => options.onScroll(-1),
-    scrollDown: () => options.onScroll(1),
-    pageUp: () => options.onScroll(options.scrollStep(-1)),
-    pageDown: () => options.onScroll(options.scrollStep(1)),
-    halfUp: () => options.onScroll(options.scrollStep(-0.5)),
-    halfDown: () => options.onScroll(options.scrollStep(0.5)),
-    home: options.onHome,
-    end: options.onEnd,
+    open: ui.filesPane.onOpenFile,
+    file: ui.filesPane.onFileScope,
+    diff: ui.filesPane.onDiffScope,
+    check: () => ui.composer.toggleFocusedTodo(),
+    removeTodo: ui.composer.removeFocusedTodo,
+    quit: () => ui.onQuit(),
+    scrollUp: () => ui.filesPane.onScroll(-1),
+    scrollDown: () => ui.filesPane.onScroll(1),
+    pageUp: () => ui.filesPane.onScroll(ui.filesPane.scrollStep(-1)),
+    pageDown: () => ui.filesPane.onScroll(ui.filesPane.scrollStep(1)),
+    halfUp: () => ui.filesPane.onScroll(ui.filesPane.scrollStep(-0.5)),
+    halfDown: () => ui.filesPane.onScroll(ui.filesPane.scrollStep(0.5)),
+    home: ui.filesPane.onHome,
+    end: ui.filesPane.onEnd,
   };
 
   const dispatch = (action) => {
-    if (CONFIRM_MODE.includes(options.getMode())) return;
-    if (options.getMode() === 'compose') {
+    if (CONFIRM_MODE.includes(ui.mode)) return;
+    if (ui.mode === 'compose') {
       if (!COMPOSE_LEAVE.includes(action)) return;
-      const result = options.composer.saveCompose();
+      const result = ui.composer.saveCompose();
       if (result && result.kind === 'error') return;
     }
-    const pane = options.getPane();
+    const pane = ui.pane;
     if (pane === 'files') {
-      if (action === 'next') return void options.onFileMove(1);
-      if (action === 'prev') return void options.onFileMove(-1);
+      if (action === 'next') return void ui.filesPane.onFileMove(1);
+      if (action === 'prev') return void ui.filesPane.onFileMove(-1);
     }
     if (pane === 'branches') {
-      if (action === 'next') return void options.onBranchMove(1);
-      if (action === 'prev') return void options.onBranchMove(-1);
+      if (action === 'next') return void ui.gitBranches.onBranchMove(1);
+      if (action === 'prev') return void ui.gitBranches.onBranchMove(-1);
     }
     if (pane === 'commits') {
-      if (action === 'next') return void options.onCommitMove(1);
-      if (action === 'prev') return void options.onCommitMove(-1);
+      if (action === 'next') return void ui.commits.onCommitMove(1);
+      if (action === 'prev') return void ui.commits.onCommitMove(-1);
     }
-    const hidden = disabledActions(pane, options.currentTarget());
+    const hidden = disabledActions(pane, currentTarget(ui));
     if (hidden.includes(action)) return;
     const handler = handlers[action];
     if (!handler) return;
@@ -75,38 +100,63 @@ const createDispatcher = (options) => {
   return { dispatch, handlers };
 };
 
-const createInput = (options) => {
+const createInput = (ui) => {
   const confirmations = {
-    confirmQuit: options.quit,
-    confirmUpdate: options.update,
-    confirmDrop: options.drop,
-    confirmPush: options.push,
+    confirmQuit: {
+      ready: () => ui.finishQuit('ready'),
+      editing: () => ui.finishQuit('editing'),
+      cancel: () => ui.cancelQuit(),
+    },
+    confirmUpdate: {
+      accept: ui.updater.accept,
+      decline: ui.updater.decline,
+    },
+    confirmDrop: {
+      confirm: () => {
+        if (ui.commits.dropName) {
+          return void ui.commits.confirmDropCommit();
+        }
+        ui.gitBranches.confirmDropBranch();
+      },
+      cancel: () => {
+        if (ui.commits.dropName) {
+          return void ui.commits.cancelDropCommit();
+        }
+        ui.gitBranches.cancelDropBranch();
+      },
+    },
+    confirmPush: {
+      force: ui.gitBranches.onForcePush,
+      cancel: ui.gitBranches.cancelPush,
+    },
   };
 
   const confirmChoice = (key) => {
-    const mode = options.getMode();
+    const mode = ui.mode;
     if (!CONFIRM_MODE.includes(mode)) return;
     applyConfirm(mode, key, confirmations[mode]);
   };
 
   const handleKey = (key) => {
-    const mode = options.getMode();
+    const mode = ui.mode;
     if (CONFIRM_MODE.includes(mode)) return void confirmChoice(key);
     if (mode === 'compose') {
-      if (key === 'ctrl-c') return void options.onQuit();
-      const command = options.composer.handleKey(key);
-      return void options.runComposeCommand(command);
+      if (key === 'ctrl-c') return void ui.onQuit();
+      const command = ui.composer.handleKey(key);
+      return void ui.runComposeCommand(command);
     }
-    if (key === 'escape') return void options.onEscape();
-    if (options.composer.typeIntoTodo(key)) return;
-    const action = actionFromKey(key, options.getPane());
-    if (action) options.dispatch(action);
+    if (key === 'escape') return void ui.filesPane.onEscape();
+    const toggle = key === 'x' || key === ' ';
+    if (toggle && ui.composer.toggleFocusedTodo()) return;
+    if (ui.composer.typeIntoTodo(key)) return;
+    const action = actionFromKey(key, ui.pane, ui.fileScope);
+    if (action) ui.dispatch(action);
   };
 
   const handleEvent = (event) => {
     if (event.type === 'key') return void handleKey(event.key);
     if (event.type !== 'mouse') return;
-    options.pointer.handle(event);
+    ui.pointer.handle(event);
   };
 
   return { handleEvent, confirmChoice };