History graph: split, squash and rebase from the change picker or a right-click menu, confirmed first and undoable; 0.8.0 b4626290e660

## 0.8.0

- The History graph rewrites history:

  - Split a head: the files you pick become a separate first change.

  - Squash a change into one of its dependencies.

  - Rebase a change onto a bookmark, change or tag.

- Use them from the change picker or by right-clicking a row. Each asks first, and afterwards offers Undo.

  tag, abandon, and split, squash and rebase from the picker or by

  right-clicking a row, each confirmed and undoable).

  "version": "0.8.0",

      },

      {

        "command": "oxygen.history.split",

        "title": "Split\u2026",

        "category": "Oxygen",

        "icon": "$(split-horizontal)"

      },

      {

        "command": "oxygen.history.squash",

        "title": "Squash into a Dependency\u2026",

        "category": "Oxygen",

        "icon": "$(fold)"

      },

      {

        "command": "oxygen.history.rebase",

        "title": "Rebase onto\u2026",

        "category": "Oxygen",

        "icon": "$(git-pull-request-go-to-changes)"

          "when": "false"

        },

        {

          "command": "oxygen.history.split",

        },

        {

          "command": "oxygen.history.squash",

          "when": "false"

        },

        {

          "command": "oxygen.history.rebase",

          "when": "false"

        }

      ],

      "webview/context": [

        {

          "command": "oxygen.history.split",

          "when": "webviewId == 'oxygen.history' && webviewSection == 'change' && oxygenHead",

          "group": "oxygen@1"

        },

        {

          "command": "oxygen.history.squash",

          "when": "webviewId == 'oxygen.history' && webviewSection == 'change' && oxygenHasDeps",

          "group": "oxygen@2"

        },

        {

          "command": "oxygen.history.rebase",

          "when": "webviewId == 'oxygen.history' && webviewSection == 'change'",

          "group": "oxygen@3"

import { Oxy, OxyError, ShowInfo, findBinary } from "./oxy";

    vscode.commands.registerCommand("oxygen.history.split", (ctx?: { root?: string; hash?: string }) => historyContext(ctx, "split")),

    vscode.commands.registerCommand("oxygen.history.squash", (ctx?: { root?: string; hash?: string }) => historyContext(ctx, "squash")),

    vscode.commands.registerCommand("oxygen.history.rebase", (ctx?: { root?: string; hash?: string }) => historyContext(ctx, "rebase")),

    ...historyItems(info),

        return;

      case "split":

      case "squash":

      case "rebase":

        await historyAction(repo, info, pick.action);

    showError(e);

  }

}

// ------------------------------------------------ history rewriting (V6)

type HistoryAction = "split" | "squash" | "rebase";

/** The rewriting actions a change offers: split for a head with several files, squash when it has dependencies, rebase always. */

function historyItems(info: ShowInfo): (vscode.QuickPickItem & { action: string })[] {

  const items: (vscode.QuickPickItem & { action: string })[] = [];

  if (info.head && info.files.length > 1) {

    items.push({ label: "$(split-horizontal) Split…", description: "chosen files become a separate first change", action: "split" });

  }

  if (info.deps.length > 0) {

    items.push({ label: "$(fold) Squash into a dependency…", description: "fold this change into one it depends on", action: "squash" });

  }

  items.push({ label: "$(git-pull-request-go-to-changes) Rebase onto…", description: "re-express against another state", action: "rebase" });

  return items;

}

/** Run `action` on a change: choose, confirm, run, then offer Undo (oxy undo reverses every rewrite). */

async function historyAction(repo: Repository, info: ShowInfo, action: HistoryAction): Promise<void> {

  const change = `#${info.hash.slice(0, 12)}`;

  const subject = info.message.split("\n")[0] || "(no description)";

  let run: () => Promise<string>;

  let question: string;

  if (action === "split") {

    if (!info.head) {

      void vscode.window.showInformationMessage("Oxygen: only a head can be split; nothing may depend on it yet.");

      return;

    }

    const picked = await vscode.window.showQuickPick(

      info.files.map((f) => ({ label: f.path, description: f.kind, picked: false })),

      { title: `Split ${info.change_id.slice(0, 8)}: the files you choose become the first change`, canPickMany: true },

    );

    if (!picked || picked.length === 0) {

      return;

    }

    if (picked.length === info.files.length) {

      void vscode.window.showInformationMessage("Oxygen: leave at least one file for the second change.");

      return;

    }

    const paths = picked.map((p) => p.label);

    question = `Split "${subject}"? ${paths.length} file${paths.length === 1 ? "" : "s"} (${paths.join(", ")}) become a separate change; the rest stay.`;

    run = () => repo.oxy.split(repo.root, change, paths);

  } else if (action === "squash") {

    if (info.deps.length === 0) {

      void vscode.window.showInformationMessage("Oxygen: this change has no dependency to fold into.");

      return;

    }

    const log = await repo.oxy.log(repo.root, 500);

    const byHash = new Map(log.changes.map((c) => [c.hash, c]));

    const choices = info.deps.map((d) => {

      const c = byHash.get(d);

      return { label: c ? c.message.split("\n")[0] || "(no description)" : d.slice(0, 12), description: c ? c.change_id.slice(0, 8) : "", hash: d };

    });

    const into = choices.length === 1 ? choices[0] : await vscode.window.showQuickPick(choices, { title: `Squash ${info.change_id.slice(0, 8)} into…` });

    if (!into) {

      return;

    }

    question = `Squash "${subject}" into "${into.label}"? The dependency keeps its ChangeId and absorbs these edits.`;

    run = () => repo.oxy.squash(repo.root, change, `#${into.hash.slice(0, 12)}`);

  } else {

    const bookmarks = await repo.oxy.bookmarks(repo.root);

    type Onto = vscode.QuickPickItem & { onto?: string };

    const choices: Onto[] = [

      ...bookmarks.map((b) => ({ label: `$(bookmark) ${b.name}`, description: b.current ? "current bookmark" : "", onto: b.name })),

      { label: "$(edit) Another change, bookmark or tag…" },

    ];

    const pick = await vscode.window.showQuickPick(choices, { title: `Rebase ${info.change_id.slice(0, 8)} onto…` });

    if (!pick) {

      return;

    }

    let onto = pick.onto;

    if (!onto) {

      onto = (await vscode.window.showInputBox({ prompt: "ChangeId prefix, #hash prefix, bookmark or tag" }))?.trim();

      if (!onto) {

        return;

      }

    }

    const target = onto;

    question = `Rebase "${subject}" onto ${target}? The change is re-expressed against that state; its ChangeId stays.`;

    run = () => repo.oxy.rebase(repo.root, change, [target]);

  }

  const verb = action[0].toUpperCase() + action.slice(1);

  if ((await vscode.window.showWarningMessage(question, { modal: true, detail: "Undo reverses it (Oxygen: Undo, or oxy undo)." }, verb)) !== verb) {

    return;

  }

  try {

    const out = await run();

    await repo.refresh();

    HistoryPanel.refresh(repo.root);

    const undo = await vscode.window.showInformationMessage(`Oxygen: ${out.split("\n")[0].replace(/^\* /, "")}`, "Undo");

    if (undo === "Undo") {

      await repo.oxy.undo(repo.root);

      await repo.refresh();

      HistoryPanel.refresh(repo.root);

    }

  } catch (e) {

    showError(e);

  }

}

/** A history-graph context menu command: the webview passes `{ root, hash }`. */

async function historyContext(ctx: { root?: string; hash?: string } | undefined, action: HistoryAction): Promise<void> {

  const repo = ctx?.root ? repositories.get(ctx.root) : undefined;

  if (!repo || !ctx?.hash) {

    return;

  }

  try {

    const info = await repo.oxy.show(repo.root, `#${ctx.hash.slice(0, 12)}`);

    await historyAction(repo, info, action);

  } catch (e) {

      // Right-click: split, squash and rebase (webview/context menus in package.json).

      const ctx = c.working_copy ? "" : ` data-vscode-context='${escape(JSON.stringify({ webviewSection: "change", root: repo.root, hash: c.hash, oxygenHead: c.head, oxygenHasDeps: c.deps.length > 0, preventDefaultContextMenuItems: true }))}'`;

      return `<div class="row${c.working_copy ? " wc" : ""}" style="top:${i * rowH}px" data-hash="${c.hash}" title="${escape(c.message)}"${ctx}>

  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");

  /** Split a head: the edits to `paths` become a separate first change. Returns oxy's summary line. */

  split(root: string, change: string, paths: string[]): Promise<string> {

    return this.check(root, ["split", change, ...paths]).then((r) => r.stdout.toString("utf8").trim());

  }

  /** Fold `change` into its dependency `into`, which keeps its ChangeId. */

  squash(root: string, change: string, into: string): Promise<string> {

    return this.check(root, ["squash", change, "--into", into]).then((r) => r.stdout.toString("utf8").trim());

  }

  /** Re-express `change` against the state of `onto` (changes, a bookmark or a tag). */

  rebase(root: string, change: string, onto: string[]): Promise<string> {

    return this.check(root, ["rebase", change, "--onto", ...onto]).then((r) => r.stdout.toString("utf8").trim());

  }

test("split, squash and rebase through the history actions, each undoable", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-hist-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(root, "a.txt"), "a\n");

  await oxy.commit(root, "one");

  writeFileSync(join(root, "b.txt"), "b\n");

  writeFileSync(join(root, "c.txt"), "c\n");

  await oxy.commit(root, "two files");

  const find = async (m) => (await oxy.log(root, 50)).changes.find((c) => !c.working_copy && c.message.startsWith(m));

  // Split: b.txt becomes its own change, c.txt stays.

  const two = await find("two files");

  const out = await oxy.split(root, `#${two.hash.slice(0, 12)}`, ["b.txt"]);

  assert.match(out, /Split into/);

  const part = await find("two files (part 1");

  assert.ok(part, "the first part exists");

  assert.deepEqual((await oxy.show(root, `#${part.hash.slice(0, 12)}`)).files.map((f) => f.path), ["b.txt"]);

  await oxy.undo(root);

  assert.equal(await find("two files (part 1"), undefined, "undo reverses the split");

  // Squash: an edit of a.txt folds into "one", which keeps its ChangeId.

  writeFileSync(join(root, "a.txt"), "a\na2\n");

  await oxy.commit(root, "edit a");

  const one = await find("one");

  const edit = await find("edit a");

  assert.deepEqual(edit.deps, [one.hash]);

  assert.match(await oxy.squash(root, `#${edit.hash.slice(0, 12)}`, `#${one.hash.slice(0, 12)}`), /Squashed into/);

  const after = await find("one");

  assert.equal(after.change_id, one.change_id);

  assert.equal(await find("edit a"), undefined);

  // Rebase onto a state that already has the change is refused, with oxy's reason.

  await assert.rejects(oxy.rebase(root, `#${after.hash.slice(0, 12)}`, ["main"]), /already part of the target state/);

});