Line links: Open on Remote, Copy Remote Link and Copy Permalink from the gutter and the editor context menu, for a line or the selection, with permalinks pinned to the bookmark's state; 0.10.0 1f7fc1e3ae4a

## 0.10.0

- **Line links:** right-click a line number, or inside the editor, for Open on Remote, Copy Remote Link and Copy Permalink.

  - The link covers the selection, or the line you clicked.

  - A permalink points at the bookmark's current state, so it keeps showing these lines after later changes.

  - If the file has uncommitted edits, a note says the lines may not match. Remote links also mention unpushed changes.

- Open on Remote in the editor title menu now includes the selected lines, not just the cursor line.

- **Links**: Open on Remote, Copy Remote Link and Copy Permalink from the

  line-number gutter and the editor context menu, for a line or the

  selection; permalinks pin the bookmark's current state.

  "version": "0.10.0",

      },

      {

        "command": "oxygen.copyRemoteLink",

        "title": "Copy Remote Link",

        "category": "Oxygen",

        "icon": "$(link)"

      },

      {

        "command": "oxygen.copyPermalink",

        "title": "Copy Permalink",

        "category": "Oxygen",

        "icon": "$(pinned)"

        },

        {

          "command": "oxygen.openOnRemote",

          "when": "oxygen.hasRemoteProvider && resourceScheme == file",

          "group": "9_oxygen@1"

        },

        {

          "command": "oxygen.copyRemoteLink",

          "when": "oxygen.hasRemoteProvider && resourceScheme == file",

          "group": "9_oxygen@2"

        },

        {

          "command": "oxygen.copyPermalink",

          "when": "oxygen.hasRemoteProvider && resourceScheme == file",

          "group": "9_oxygen@3"

          "group": "oxygen@1"

        },

        {

          "command": "oxygen.copyPermalink",

          "when": "oxygen.hasRemoteProvider",

          "group": "oxygen@2"

          "group": "oxygen@3"

        }

      ],

      "editor/lineNumber/context": [

        {

          "command": "oxygen.openOnRemote",

          "when": "oxygen.hasRemoteProvider && resourceScheme == file",

          "group": "oxygen@1"

        },

        {

          "command": "oxygen.copyRemoteLink",

          "when": "oxygen.hasRemoteProvider && resourceScheme == file",

          "group": "oxygen@2"

        },

        {

          "command": "oxygen.copyPermalink",

          "when": "oxygen.hasRemoteProvider && resourceScheme == file",

  | { kind: "file"; reference: string; path: string; line?: number; endLine?: number }

}

/**

 * A state address for permalinks, as OxygenHub writes it: the state's head

 * hashes, sorted and joined with `+`. Undefined without heads.

 */

export function stateSpec(heads: readonly string[]): string | undefined {

  const hex = [...new Set(heads.map((h) => h.toLowerCase()))].filter((h) => /^[0-9a-f]{64}$/.test(h)).sort();

  return hex.length > 0 && hex.length === new Set(heads).size ? hex.join("+") : undefined;

}

/**

 * The 1-based lines to link: the selection when the clicked line is inside it

 * (or nothing was clicked), otherwise the clicked line alone. `selection` is

 * 1-based and inclusive; a selection ending at column 0 of a line does not

 * include that line.

 */

export function linkedLines(clicked: number | undefined, selection: { start: number; end: number; endColumn: number; empty: boolean }): { line: number; endLine?: number } {

  let end = selection.end;

  if (!selection.empty && selection.endColumn === 0 && end > selection.start) {

    end -= 1;

  }

  if (clicked !== undefined && (selection.empty || clicked < selection.start || clicked > end)) {

    return { line: clicked };

  }

  if (selection.empty || end === selection.start) {

    return { line: selection.start };

  }

  return { line: selection.start, endLine: end };

import { OxygenAPI, RemoteProvider, RemoteTarget, RepositoryHandle, linkedLines, pickProvider, repositoryFor as rootFor, stateSpec } from "./api";

    vscode.commands.registerCommand("oxygen.openOnRemote", (arg?: Repository | vscode.SourceControl | LinkArg) =>

      openOnRemote(undefined, arg instanceof Repository ? arg : undefined, "open", arg instanceof Repository || isSourceControl(arg) ? undefined : (arg as LinkArg)),

    ),

    vscode.commands.registerCommand("oxygen.copyRemoteLink", (arg?: LinkArg) => openOnRemote(undefined, undefined, "copy", arg)),

    vscode.commands.registerCommand("oxygen.copyPermalink", (arg?: LinkArg) => openOnRemote(undefined, undefined, "permalink", arg)),

/** What a remote-link command does with the URL. */

type LinkMode = "open" | "copy" | "permalink";

/** The editor gutter passes `{ lineNumber, uri }`; an editor title menu passes the file's Uri. */

type LinkArg = { lineNumber?: number; uri?: vscode.Uri } | vscode.Uri | undefined;

/**

 * Open or copy a link to the current repository, file or change on

 * whichever provider knows its remote. For a file, the lines are the

 * gutter's clicked line or the selection; `permalink` pins the link to the

 * bookmark's current state (its heads), so it keeps pointing at these lines.

 */

async function openOnRemote(target?: RemoteTarget, repoArg?: Repository, mode: LinkMode = "open", arg?: LinkArg): Promise<void> {

  const argUri = arg instanceof vscode.Uri ? arg : arg?.uri;

  const clicked = arg && !(arg instanceof vscode.Uri) ? arg.lineNumber : undefined;

  const docUri = argUri ?? editor?.document.uri;

  const repo = repoArg ?? (docUri ? repositoryFor2(docUri) : undefined) ?? [...repositories.values()][0];

  let note = "";

  if (!target && docUri) {

    const rel = repo.relativePath(docUri);

      const bookmark = repo.currentBookmark;

      let reference = bookmark?.name ?? "main";

      if (mode === "permalink") {

        const spec = stateSpec(bookmark?.heads ?? []);

        if (!spec) {

          void vscode.window.showInformationMessage("Oxygen: this bookmark has no committed state to link to yet.");

          return;

        }

        reference = spec;

      }

      const sameDoc = editor && editor.document.uri.toString() === docUri.toString();

      const sel = sameDoc

        ? { start: editor.selection.start.line + 1, end: editor.selection.end.line + 1, endColumn: editor.selection.end.character, empty: editor.selection.isEmpty }

        : { start: clicked ?? 1, end: clicked ?? 1, endColumn: 0, empty: true };

      const lines = clicked !== undefined || sameDoc ? linkedLines(clicked, sel) : {};

      t = { kind: "file", reference, path: rel, ...lines };

      // Lines are counted in the editor; say so when they may not match the remote.

      const edited = repo.status?.paths.some((p) => p.path === rel);

      if (edited || (sameDoc && editor.document.isDirty)) {

        note = " The file has uncommitted edits, so the lines may differ from the remote's.";

      } else if (mode !== "permalink" && bookmark && bookmark.ahead !== null && bookmark.ahead > 0) {

        note = ` ${bookmark.name} has unpushed changes; the remote may not show them yet.`;

      }

  if (!url) {

    return;

  }

  if (mode === "open") {

    if (note) {

      void vscode.window.showInformationMessage(`Oxygen:${note}`);

    }

    return;

  await vscode.env.clipboard.writeText(url);

  const what = mode === "permalink" ? "Permalink" : "Link";

  if (note) {

    void vscode.window.showWarningMessage(`Oxygen: ${what} copied.${note}`);

  } else {

    vscode.window.setStatusBarMessage(`$(link) ${what} copied`, 4000);

  }

}

function isSourceControl(arg: unknown): arg is vscode.SourceControl {

  return typeof arg === "object" && arg !== null && "inputBox" in arg && "rootUri" in arg;

test("permalink state addresses match OxygenHub's", async () => {

  const { stateSpec } = await import("../out/api.mjs");

  const a = "b".repeat(64), b = "a".repeat(64);

  assert.equal(stateSpec([a, b, a.toUpperCase()]), undefined, "mixed-case duplicates are not a state");

  assert.equal(stateSpec([a, b]), `${b}+${a}`, "sorted and joined with +");

  assert.equal(stateSpec([a]), a);

  assert.equal(stateSpec([]), undefined);

  assert.equal(stateSpec(["abc"]), undefined, "full hashes only");

});

test("linked lines follow the click and the selection", async () => {

  const { linkedLines } = await import("../out/api.mjs");

  const none = { start: 5, end: 5, endColumn: 3, empty: true };

  assert.deepEqual(linkedLines(undefined, none), { line: 5 });

  assert.deepEqual(linkedLines(12, none), { line: 12 }, "gutter click without a selection");

  const sel = { start: 10, end: 20, endColumn: 4, empty: false };

  assert.deepEqual(linkedLines(undefined, sel), { line: 10, endLine: 20 });

  assert.deepEqual(linkedLines(15, sel), { line: 10, endLine: 20 }, "a click inside the selection keeps it");

  assert.deepEqual(linkedLines(30, sel), { line: 30 }, "a click outside wins");

  assert.deepEqual(linkedLines(undefined, { start: 10, end: 21, endColumn: 0, empty: false }), { line: 10, endLine: 20 }, "a selection ending at column 0 stops the line before");

  assert.deepEqual(linkedLines(undefined, { start: 7, end: 7, endColumn: 9, empty: false }), { line: 7 });

});