reslop 0.2.4 → 0.2.6

package/lib/review-merge.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const files = require('./files.js');
-const { TODO_FILE } = files;
+const { TASKS_FILE, taskKind } = files;
 
 const flatText = (text) => `${text ?? ''}`.trim().replace(/\n/g, ' ');
 
@@ -9,28 +9,20 @@ const snapTodo = (todo) => ({
   file: todo.file ?? '',
   text: flatText(todo.text),
   done: todo.done === true,
+  kind: taskKind(todo),
 });
 
-const snapList = (todos) => {
-  const list = [];
-  for (const todo of todos ?? []) {
-    const snap = snapTodo(todo);
-    if (!snap.text) continue;
-    list.push(snap);
-  }
-  return list;
-};
+const snapList = (todos) => todos.map(snapTodo).filter((snap) => snap.text);
 
 const copyMap = (map) => {
   const next = new Map();
-  if (!map) return next;
   for (const [key, note] of map) next.set(key, { ...note });
   return next;
 };
 
 const snapshotSide = (store) => ({
   status: store.status,
-  todos: snapList(store.todos),
+  tasks: snapList(store.tasks),
   feedback: copyMap(store.feedback),
   code: copyMap(store.code),
 });
@@ -58,162 +50,137 @@ const pickDone = (baseDone, ourDone, theirDone) => {
 
 const withDone = (todo, done) => {
   if (todo.done === done) return todo;
-  return { id: todo.id, file: todo.file, text: todo.text, done };
+  return { ...todo, done };
 };
 
 const liveText = (todo) => flatText(todo.text);
 
 const snapText = (snap) => snap.text;
 
+const liveKey = (todo) => `${taskKind(todo)}\0${liveText(todo)}`;
+
+const snapKey = (snap) => `${taskKind(snap)}\0${snapText(snap)}`;
+
 const flags = (n) => new Array(n).fill(false);
 
 const adoptTodo = (store, snap) => {
-  const id = store.nextTodoId;
-  store.nextTodoId += 1;
-  const file = snap.file || TODO_FILE;
-  return { id, file, text: snap.text, done: snap.done };
+  const id = store.nextTaskId;
+  store.nextTaskId += 1;
+  const file = snap.file || TASKS_FILE;
+  return { id, file, text: snap.text, done: snap.done, kind: taskKind(snap) };
 };
 
-const findMerged = (merged, alias, text) => {
-  const linked = alias.get(text);
-  if (linked) {
-    const at = merged.indexOf(linked);
-    if (at >= 0) return at;
-  }
-  for (let i = 0; i < merged.length; i++) {
-    if (liveText(merged[i]) === text) return i;
-  }
-  return -1;
-};
+const replaceTodo = (todo, snap) => ({
+  ...todo,
+  text: snap.text,
+  done: snap.done,
+  kind: taskKind(snap),
+});
 
-const insertTheir = (store, merged, theirs, theirKeep, alias) => {
-  for (let i = 0; i < theirs.length; i++) {
-    if (!theirKeep[i]) continue;
-    let at = merged.length;
-    let placed = false;
-    for (let j = i - 1; j >= 0 && !placed; j--) {
-      const prev = findMerged(merged, alias, theirs[j].text);
-      if (prev < 0) continue;
-      at = prev + 1;
-      placed = true;
+class TodoMerge {
+  constructor(store, theirs) {
+    this.store = store;
+    this.ours = store.tasks.filter((todo) => liveText(todo));
+    this.theirs = theirs;
+    this.usedOurs = flags(this.ours.length);
+    this.usedTheirs = flags(theirs.length);
+    this.kept = flags(this.ours.length);
+    this.dropped = flags(this.ours.length);
+    this.theirKeep = flags(theirs.length);
+    this.alias = new Map();
+  }
+
+  keepOurs(index) {
+    this.kept[index] = true;
+    this.alias.set(liveKey(this.ours[index]), this.ours[index]);
+  }
+
+  mergeBase(base) {
+    const { ours, theirs } = this;
+    const key = snapKey(base);
+    const oi = claim(ours, this.usedOurs, key, liveKey);
+    const ti = claim(theirs, this.usedTheirs, key, snapKey);
+    if (oi >= 0 && ti >= 0) {
+      const done = pickDone(base.done, ours[oi].done === true, theirs[ti].done);
+      ours[oi] = withDone(ours[oi], done);
+      this.keepOurs(oi);
+    } else if (oi >= 0) {
+      if (ours[oi].done === base.done) this.dropped[oi] = true;
+      else this.keepOurs(oi);
+    } else if (ti >= 0 && theirs[ti].done !== base.done) {
+      this.theirKeep[ti] = true;
     }
-    for (let j = i + 1; j < theirs.length && !placed; j++) {
-      const next = findMerged(merged, alias, theirs[j].text);
-      if (next < 0) continue;
-      at = next;
-      placed = true;
-    }
-    const item = adoptTodo(store, theirs[i]);
-    merged.splice(at, 0, item);
-    alias.set(theirs[i].text, item);
   }
-  return merged;
-};
-
-const keepOurs = (ours, kept, alias, index, text) => {
-  kept[index] = true;
-  alias.set(text, ours[index]);
-};
 
-const mergeBaseTodo = (
-  base,
-  ours,
-  theirs,
-  used,
-  kept,
-  dropped,
-  theirKeep,
-  alias,
-) => {
-  const text = base.text;
-  const oi = claim(ours, used.ours, text, liveText);
-  const ti = claim(theirs, used.theirs, text, snapText);
-  if (oi >= 0 && ti >= 0) {
-    const done = pickDone(base.done, ours[oi].done === true, theirs[ti].done);
-    ours[oi] = withDone(ours[oi], done);
-    keepOurs(ours, kept, alias, oi, text);
-    return;
-  }
-  if (oi >= 0) {
-    if (ours[oi].done === base.done) {
-      dropped[oi] = true;
+  mergeFresh(index) {
+    const { ours, theirs } = this;
+    const key = liveKey(ours[index]);
+    const ti = claim(theirs, this.usedTheirs, key, snapKey);
+    if (ti < 0) {
+      this.kept[index] = true;
       return;
     }
-    keepOurs(ours, kept, alias, oi, text);
-    return;
+    const done = ours[index].done === true || theirs[ti].done === true;
+    ours[index] = withDone(ours[index], done);
+    this.keepOurs(index);
   }
-  if (ti >= 0 && theirs[ti].done !== base.done) theirKeep[ti] = true;
-};
 
-const replaceTodo = (todo, snap) => ({
-  id: todo.id,
-  file: todo.file,
-  text: snap.text,
-  done: snap.done,
-});
-
-const fillGaps = (merged, gaps, theirs, theirKeep, alias) => {
-  let filled = 0;
-  for (let i = 0; i < theirs.length && filled < gaps.length; i++) {
-    if (!theirKeep[i]) continue;
-    const gap = gaps[filled];
-    const item = replaceTodo(gap.todo, theirs[i]);
-    merged.splice(gap.at, 0, item);
-    alias.set(theirs[i].text, item);
-    theirKeep[i] = false;
-    filled += 1;
+  findMerged(merged, snap) {
+    const key = snapKey(snap);
+    const linked = this.alias.get(key);
+    const at = linked ? merged.indexOf(linked) : -1;
+    if (at >= 0) return at;
+    return merged.findIndex((todo) => liveKey(todo) === key);
   }
-};
 
-const mergeFreshTodo = (ours, theirs, used, kept, alias, index) => {
-  const text = liveText(ours[index]);
-  const ti = claim(theirs, used.theirs, text, snapText);
-  if (ti < 0) {
-    kept[index] = true;
-    return;
+  theirPlace(merged, index) {
+    const { theirs } = this;
+    for (let j = index - 1; j >= 0; j--) {
+      const prev = this.findMerged(merged, theirs[j]);
+      if (prev >= 0) return prev + 1;
+    }
+    for (let j = index + 1; j < theirs.length; j++) {
+      const next = this.findMerged(merged, theirs[j]);
+      if (next >= 0) return next;
+    }
+    return merged.length;
   }
-  const done = ours[index].done === true || theirs[ti].done === true;
-  ours[index] = withDone(ours[index], done);
-  keepOurs(ours, kept, alias, index, text);
-};
 
-const mergeTodos = (store, base, theirs) => {
-  const ours = [];
-  for (const todo of store.todos) {
-    if (!liveText(todo)) continue;
-    ours.push(todo);
-  }
-  const used = { ours: flags(ours.length), theirs: flags(theirs.length) };
-  const kept = flags(ours.length);
-  const dropped = flags(ours.length);
-  const theirKeep = flags(theirs.length);
-  const alias = new Map();
-  for (const item of base) {
-    mergeBaseTodo(item, ours, theirs, used, kept, dropped, theirKeep, alias);
-  }
-  for (let i = 0; i < ours.length; i++) {
-    if (used.ours[i]) continue;
-    mergeFreshTodo(ours, theirs, used, kept, alias, i);
-  }
-  for (let i = 0; i < theirs.length; i++) {
-    if (!used.theirs[i]) theirKeep[i] = true;
+  place(merged, at, index, item) {
+    merged.splice(at, 0, item);
+    this.alias.set(snapKey(this.theirs[index]), item);
+    this.theirKeep[index] = false;
   }
-  const merged = [];
-  const gaps = [];
-  let cursor = 0;
-  for (let i = 0; i < ours.length; i++) {
-    if (kept[i]) {
-      merged.push(ours[i]);
-      cursor += 1;
-      continue;
+
+  merge(base) {
+    const { ours, theirs } = this;
+    for (const item of base) this.mergeBase(item);
+    for (let i = 0; i < ours.length; i++) {
+      if (!this.usedOurs[i]) this.mergeFresh(i);
     }
-    if (!dropped[i]) continue;
-    gaps.push({ at: cursor, todo: ours[i] });
-    cursor += 1;
+    for (let i = 0; i < theirs.length; i++) {
+      if (!this.usedTheirs[i]) this.theirKeep[i] = true;
+    }
+    const merged = [];
+    const gaps = [];
+    for (let i = 0; i < ours.length; i++) {
+      const at = merged.length + gaps.length;
+      if (this.kept[i]) merged.push(ours[i]);
+      else if (this.dropped[i]) gaps.push({ at, task: ours[i] });
+    }
+    for (let i = 0; i < theirs.length && gaps.length; i++) {
+      if (!this.theirKeep[i]) continue;
+      const gap = gaps.shift();
+      this.place(merged, gap.at, i, replaceTodo(gap.task, theirs[i]));
+    }
+    for (let i = 0; i < theirs.length; i++) {
+      if (!this.theirKeep[i]) continue;
+      const at = this.theirPlace(merged, i);
+      this.place(merged, at, i, adoptTodo(this.store, theirs[i]));
+    }
+    return merged;
   }
-  fillGaps(merged, gaps, theirs, theirKeep, alias);
-  store.todos = insertTheir(store, merged, theirs, theirKeep, alias);
-};
+}
 
 const sameNote = (left, right) =>
   left.text === right.text && !!left.done === !!right.done;
@@ -244,10 +211,7 @@ const pickNote = (ours, base, theirs) => {
 };
 
 const mergeMap = (ours, base, theirs) => {
-  const keys = new Set();
-  for (const key of ours.keys()) keys.add(key);
-  for (const key of base.keys()) keys.add(key);
-  for (const key of theirs.keys()) keys.add(key);
+  const keys = new Set([...ours.keys(), ...base.keys(), ...theirs.keys()]);
   for (const key of keys) {
     const next = pickNote(ours.get(key), base.get(key), theirs.get(key));
     if (!next) ours.delete(key);
@@ -257,13 +221,11 @@ const mergeMap = (ours, base, theirs) => {
 
 const mergeReview = (store, disk) => {
   const base = store.baseline;
-  const baseTodos = base ? base.todos : [];
   const baseStatus = base ? base.status : store.status;
-  mergeTodos(store, baseTodos, snapList(disk.todos));
-  const feedback = base ? base.feedback : new Map();
-  const code = base ? base.code : new Map();
-  mergeMap(store.feedback, feedback, disk.feedback);
-  mergeMap(store.code, code, disk.code);
+  const theirs = snapList(disk.tasks);
+  store.tasks = new TodoMerge(store, theirs).merge(base?.tasks ?? []);
+  mergeMap(store.feedback, base?.feedback ?? new Map(), disk.feedback);
+  mergeMap(store.code, base?.code ?? new Map(), disk.code);
   if (store.status === baseStatus && disk.status) store.status = disk.status;
   store.baseline = snapshotSide(disk);
 };