Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(vcs): inline blame for the current line (#778)

l0ng-ai8e8a998abe37
diff --git a/crates/ide-core/src/workflow_settings.rs b/crates/ide-core/src/workflow_settings.rs
index 64fb58fbe..3b31a576f 100644
--- a/crates/ide-core/src/workflow_settings.rs
+++ b/crates/ide-core/src/workflow_settings.rs
@@ -41,6 +41,8 @@ impl Default for VcsSettings {
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct GitSettings {
+ /// Show blame after the current editor line.
+ pub inline_blame: bool,
/// Path to the git executable; empty = auto-detect.
pub executable: String,
/// Default of Update Project: `merge` | `rebase`.
@@ -71,6 +73,7 @@ pub struct GitSettings {
impl Default for GitSettings {
fn default() -> Self {
Self {
+ inline_blame: false,
executable: String::new(),
update_method: "merge".into(),
auto_update_on_push_rejected: false,
diff --git a/src/bindings.ts b/src/bindings.ts
index e2eb8a2ae..7c4a2d955 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -3350,6 +3350,8 @@ export type GitOperation =
{ op: "interactiveRebase"; base: string | null; entries: RebaseEntry[] };
export type GitSettings = {
+ /** Show blame after the current editor line. */
+ inlineBlame?: boolean,
/** Path to the git executable; empty = auto-detect. */
executable?: string,
/** Default of Update Project: `merge` | `rebase`. */
diff --git a/src/editor/api.ts b/src/editor/api.ts
index 9f0251cbf..9d1e81e01 100644
--- a/src/editor/api.ts
+++ b/src/editor/api.ts
@@ -32,6 +32,9 @@ import type { LanguageDescription } from "@codemirror/language";
import { create } from "zustand";
import { maybeEditorService } from "@/workbench/contributions";
+/** Documents above this size (UTF-16 units) skip per-line decorations. */
+export const HEAVY_LIMIT = 8_000_000;
+
export interface EditorDocContext {
doc: number;
path: string;
diff --git a/src/editor/core/cm/setup.ts b/src/editor/core/cm/setup.ts
index bcecc965e..059b6c139 100644
--- a/src/editor/core/cm/setup.ts
+++ b/src/editor/core/cm/setup.ts
@@ -28,7 +28,7 @@ import type { EditorConfigProps } from "@/bindings";
import type { EditorSettings } from "@/platform/ipc";
import { editorPrefs, lineCommentStyleFor, type EditorExtras } from "@/platform/editorSettings";
import { BUNDLED_MONO_FAMILY, monoFontFamily } from "@/platform/fonts";
-import { editorContributions, type EditorDocContext } from "@/editor/api";
+import { editorContributions, HEAVY_LIMIT, type EditorDocContext } from "@/editor/api";
import { distractionFreeWidth, isDistractionFree } from "@/workbench/distractionFree";
import { openideaHighlightStyle } from "./highlight";
import { openideaTheme } from "./theme";
@@ -78,8 +78,7 @@ export function prefsOf(settings: EditorSettings | undefined): EditorExtras {
return editorPrefs({ editor: settings });
}
-/** Documents above this size (UTF-16 units) skip per-line decorations. */
-export const HEAVY_LIMIT = 8_000_000;
+export { HEAVY_LIMIT } from "@/editor/api";
export interface EffectiveIndent {
tabSize: number;
diff --git a/src/features/settings/pages/vcs.tsx b/src/features/settings/pages/vcs.tsx
index 225095a0e..db0875711 100644
--- a/src/features/settings/pages/vcs.tsx
+++ b/src/features/settings/pages/vcs.tsx
@@ -492,6 +492,7 @@ export const VCS_PAGES: PageSpec[] = [
keywords: ["Test", "git version"],
component: GitExecutableRow,
},
+ { kind: "toggle", key: "vcs.git.inlineBlame", label: "Show inline blame for the current line" },
],
},
{
diff --git a/src/features/vcs/__tests__/inlineBlame.test.ts b/src/features/vcs/__tests__/inlineBlame.test.ts
new file mode 100644
index 000000000..e49cb3de8
--- /dev/null
+++ b/src/features/vcs/__tests__/inlineBlame.test.ts
@@ -0,0 +1,255 @@
+import { EditorSelection, EditorState } from "@codemirror/state";
+import { EditorView, activateHover, closeHoverTooltips, hasHoverTooltips } from "@codemirror/view";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { BlameLine, Settings } from "@/bindings";
+import { HEAVY_LIMIT, _emitEditorEvent } from "@/editor/api";
+import { useProject } from "@/platform/project";
+import { useI18n } from "@/platform/i18n";
+import { formatInlineBlame, inlineBlame, relativeBlameDate } from "../inlineBlame";
+import { useVcs } from "../store";
+
+const mocks = vi.hoisted(() => ({ blame: vi.fn(), file: vi.fn(), log: vi.fn(), action: vi.fn() }));
+vi.mock("@/platform/actions", async (original) => ({
+ ...(await original<typeof import("@/platform/actions")>()),
+ executeAction: mocks.action,
+}));
+vi.mock("@/platform/ipc", async (original) => {
+ const actual = await original<typeof import("@/platform/ipc")>();
+ return {
+ ...actual,
+ isTauri: () => true,
+ commands: { ...actual.commands, vcsBlame: mocks.blame, vcsFileAt: mocks.file, vcsLog: mocks.log },
+ };
+});
+
+const now = Date.UTC(2026, 10, 2, 12);
+const alice: BlameLine = {
+ commit: "a".repeat(40),
+ author: "Alice Smith",
+ timeMs: now - 86400_000,
+ summary: "First line",
+};
+const bob: BlameLine = { commit: "b".repeat(40), author: "Bob Jones", timeMs: now - 3600_000, summary: "Second line" };
+const uncommitted: BlameLine = { commit: "0".repeat(40), author: "Not Committed Yet", timeMs: now, summary: "" };
+const ctx = { doc: 1, path: "/repo/file.ts", language: "typescript", uiMode: null, readOnly: false };
+let view: EditorView | undefined;
+
+function settings(enabled: boolean) {
+ useProject.setState({ settings: { vcs: { git: { inlineBlame: enabled } } } as Settings });
+}
+
+function editor(doc = "one\ntwo\nthree", context = ctx) {
+ view = new EditorView({
+ parent: document.body,
+ state: EditorState.create({ doc, extensions: [inlineBlame(context)] }),
+ });
+ return view;
+}
+
+const hint = () => view?.dom.querySelector<HTMLElement>(".cm-vcs-inline-blame");
+const tick = () => vi.advanceTimersByTimeAsync(300);
+
+beforeEach(() => {
+ vi.useFakeTimers();
+ vi.setSystemTime(now);
+ vi.clearAllMocks();
+ useI18n.setState({ locale: "en", texts: {} });
+ settings(true);
+ useVcs.setState({ available: true, roots: ["/repo"], statusLoaded: true, byPath: new Map(), version: 0 });
+ mocks.file.mockResolvedValue({ status: "ok", data: "one\ntwo\nthree" });
+ mocks.blame.mockResolvedValue({ status: "ok", data: [alice, bob, uncommitted] });
+});
+
+afterEach(() => {
+ view?.destroy();
+ view = undefined;
+ useProject.setState({ settings: null });
+ vi.useRealTimers();
+});
+
+describe("inline blame formatting", () => {
+ it("formats authors, relative dates, summaries and missing dates", () => {
+ expect(formatInlineBlame(alice, now)).toBe("Alice Smith, 1 day ago · First line");
+ expect(formatInlineBlame({ ...bob, timeMs: null, summary: "Long\nmessage" }, now)).toBe("Bob Jones · Long message");
+ expect(formatInlineBlame(uncommitted, now)).toBe("You, now · Uncommitted changes");
+ expect(relativeBlameDate(now + 1000, now)).toBe("now");
+ expect(relativeBlameDate(now - 120_000, now)).toBe("2 minutes ago");
+ expect(relativeBlameDate(now - 400 * 86400_000, now)).toBe("1 year ago");
+ });
+});
+
+describe("current line decoration", () => {
+ it("debounces caret moves and reuses blame for the same document version", async () => {
+ const v = editor();
+ await vi.advanceTimersByTimeAsync(299);
+ expect(mocks.blame).not.toHaveBeenCalled();
+ v.dispatch({ selection: { anchor: 4 } });
+ await vi.advanceTimersByTimeAsync(299);
+ expect(mocks.blame).not.toHaveBeenCalled();
+ await vi.advanceTimersByTimeAsync(1);
+ expect(hint()?.textContent).toContain("Bob Jones");
+ v.dispatch({ selection: { anchor: 0 } });
+ expect(hint()).toBeNull();
+ await tick();
+ expect(hint()?.textContent).toContain("Alice Smith");
+ expect(mocks.blame).toHaveBeenCalledTimes(1);
+ expect(mocks.file).toHaveBeenCalledTimes(1);
+ expect(hint()?.contentEditable).toBe("false");
+ hint()?.click();
+ expect(mocks.action).toHaveBeenCalledWith("vcs.showCommit", alice.commit);
+ });
+
+ it("uses only the primary selection and hides multiline selections", async () => {
+ const v = editor();
+ v.dispatch({ selection: EditorSelection.create([EditorSelection.cursor(0), EditorSelection.cursor(4)], 1) });
+ await tick();
+ expect(hint()?.textContent).toContain("Bob Jones");
+ v.dispatch({ selection: { anchor: 0, head: 5 } });
+ await tick();
+ expect(hint()).toBeNull();
+ v.dispatch({ selection: { anchor: 4, head: 6 } });
+ await tick();
+ expect(hint()?.textContent).toContain("Bob Jones");
+ });
+
+ it("loads and caches the full commit message on hover and closes it on caret movement", async () => {
+ const message = "First line\n\nThe complete commit body.";
+ mocks.log.mockResolvedValue({ status: "ok", data: [{ message }] });
+ const v = editor();
+ await tick();
+ activateHover(v, 3, 1);
+ await vi.advanceTimersByTimeAsync(0);
+ expect(hasHoverTooltips(v.state)).toBe(true);
+ const tooltip = v.dom.querySelector(".cm-vcs-inline-blame-tooltip");
+ expect(tooltip?.textContent).toContain(message);
+ expect(tooltip?.textContent).toContain(alice.author);
+ expect(tooltip?.textContent).toContain(alice.commit);
+ expect(tooltip?.textContent).toContain(new Date(alice.timeMs!).toLocaleString());
+ v.dispatch({ effects: closeHoverTooltips });
+ activateHover(v, 3, 1);
+ await vi.advanceTimersByTimeAsync(0);
+ expect(mocks.log).toHaveBeenCalledTimes(1);
+ v.dispatch({ selection: { anchor: 4 } });
+ expect(hasHoverTooltips(v.state)).toBe(false);
+ });
+
+ it("closes an open tooltip when the setting is disabled", async () => {
+ mocks.log.mockResolvedValue({ status: "ok", data: [{ message: "Full message" }] });
+ const v = editor();
+ await tick();
+ activateHover(v, 3, 1);
+ await vi.advanceTimersByTimeAsync(0);
+ expect(hasHoverTooltips(v.state)).toBe(true);
+ settings(false);
+ expect(hasHoverTooltips(v.state)).toBe(false);
+ });
+
+ it("refetches edits, saves and VCS refreshes", async () => {
+ const v = editor();
+ await tick();
+ mocks.blame.mockResolvedValue({ status: "ok", data: [uncommitted, bob, uncommitted] });
+ v.dispatch({ changes: { from: 0, insert: "x" } });
+ expect(hint()).toBeNull();
+ await tick();
+ expect(mocks.blame).toHaveBeenLastCalledWith(ctx.path, "xone\ntwo\nthree", null);
+ expect(hint()?.textContent).toBe("You, now · Uncommitted changes");
+ _emitEditorEvent({ type: "docSaved", doc: 1, path: ctx.path });
+ await tick();
+ useVcs.setState({ version: 1 });
+ await tick();
+ expect(mocks.blame).toHaveBeenCalledTimes(4);
+ });
+
+ it("discards a response from an older document version", async () => {
+ let resolve!: (result: { status: "ok"; data: BlameLine[] }) => void;
+ mocks.blame.mockReturnValueOnce(new Promise((done) => (resolve = done)));
+ const v = editor();
+ await tick();
+ v.dispatch({ changes: { from: 0, insert: "x" } });
+ resolve({ status: "ok", data: [alice] });
+ await vi.advanceTimersByTimeAsync(0);
+ expect(hint()).toBeNull();
+ mocks.blame.mockResolvedValue({ status: "ok", data: [uncommitted] });
+ await tick();
+ expect(hint()?.textContent).toBe("You, now · Uncommitted changes");
+ });
+
+ it("coalesces an in-flight blame when the caret moves", async () => {
+ let resolve!: (result: { status: "ok"; data: BlameLine[] }) => void;
+ mocks.blame.mockReturnValueOnce(new Promise((done) => (resolve = done)));
+ const v = editor();
+ await tick();
+ v.dispatch({ selection: { anchor: 4 } });
+ await tick();
+ resolve({ status: "ok", data: [alice, bob] });
+ await vi.advanceTimersByTimeAsync(0);
+ expect(hint()?.textContent).toContain("Bob Jones");
+ expect(mocks.blame).toHaveBeenCalledTimes(1);
+ });
+
+ it("responds to the setting immediately", async () => {
+ settings(false);
+ editor();
+ await tick();
+ expect(mocks.blame).not.toHaveBeenCalled();
+ settings(true);
+ await tick();
+ expect(hint()).not.toBeNull();
+ settings(false);
+ expect(hint()).toBeNull();
+ await tick();
+ expect(mocks.blame).toHaveBeenCalledTimes(1);
+ });
+
+ it("ignores a pending response after disabling", async () => {
+ let resolve!: (result: { status: "ok"; data: BlameLine[] }) => void;
+ mocks.blame.mockReturnValueOnce(new Promise((done) => (resolve = done)));
+ editor();
+ await tick();
+ settings(false);
+ resolve({ status: "ok", data: [alice] });
+ await vi.advanceTimersByTimeAsync(0);
+ expect(hint()).toBeNull();
+ await tick();
+ expect(hint()).toBeNull();
+ });
+
+ it.each(["untracked", "ignored"] as const)("skips %s paths", async (unstaged) => {
+ useVcs.setState({
+ byPath: new Map([[ctx.path, { path: ctx.path, relPath: "file.ts", unstaged, staged: null, renamedFrom: null }]]),
+ });
+ editor();
+ await tick();
+ expect(mocks.file).not.toHaveBeenCalled();
+ expect(hint()).toBeNull();
+ });
+
+ it("skips ignored paths missing from status and HEAD", async () => {
+ mocks.file.mockResolvedValue({ status: "ok", data: null });
+ editor();
+ await tick();
+ expect(mocks.blame).not.toHaveBeenCalled();
+ expect(hint()).toBeNull();
+ });
+
+ it("skips paths outside repositories", async () => {
+ editor("one", { ...ctx, path: "/elsewhere/file.ts" });
+ await tick();
+ expect(mocks.file).not.toHaveBeenCalled();
+ });
+
+ it("skips large, virtual and read-only documents", async () => {
+ editor("x".repeat(HEAVY_LIMIT + 1));
+ await tick();
+ expect(mocks.file).not.toHaveBeenCalled();
+ expect(inlineBlame({ ...ctx, virtual: true })).toEqual([]);
+ expect(inlineBlame({ ...ctx, readOnly: true })).toEqual([]);
+ });
+
+ it("cancels pending work when the view is destroyed", async () => {
+ editor().destroy();
+ view = undefined;
+ await tick();
+ expect(mocks.file).not.toHaveBeenCalled();
+ });
+});
diff --git a/src/features/vcs/index.ts b/src/features/vcs/index.ts
index 801985175..9e74b30c3 100644
--- a/src/features/vcs/index.ts
+++ b/src/features/vcs/index.ts
@@ -23,6 +23,7 @@ import { registerHistoryActions, trackOperationContext } from "./historyActions"
import { registerLogPaneActions } from "./logPaneActions";
import { controlLabel, controlOperation, inProgress } from "./operations";
import { annotationsShown, blameSlot } from "./blame";
+import { inlineBlame } from "./inlineBlame";
import { BranchWidget, useBranchesPopup } from "./BranchWidget";
import { showConflictsDialog } from "./conflictsUi";
import { registerCompareActions } from "./compare";
@@ -212,7 +213,7 @@ export function activate(): () => void {
registerEditorContribution({
id: "vcs.changeMarkers",
order: 60,
- extensions: (ctx) => [changeMarkers(ctx), blameSlot()],
+ extensions: (ctx) => [changeMarkers(ctx), blameSlot(), inlineBlame(ctx)],
}),
registerMenuGroup({
id: "vcs.gutter",
diff --git a/src/features/vcs/inlineBlame.ts b/src/features/vcs/inlineBlame.ts
new file mode 100644
index 000000000..047b3136c
--- /dev/null
+++ b/src/features/vcs/inlineBlame.ts
@@ -0,0 +1,281 @@
+import { StateEffect, StateField, type Extension, type Text } from "@codemirror/state";
+import {
+ Decoration,
+ EditorView,
+ ViewPlugin,
+ WidgetType,
+ hoverTooltip,
+ type DecorationSet,
+ type ViewUpdate,
+} from "@codemirror/view";
+import type { BlameLine } from "@/bindings";
+import { HEAVY_LIMIT, onEditorEvent, type EditorDocContext } from "@/editor/api";
+import { executeAction } from "@/platform/actions";
+import { tx, useI18n } from "@/platform/i18n";
+import { call, commands, isTauri } from "@/platform/ipc";
+import { onWorkflowSettingsChange, workflowSettings } from "@/platform/workflowSettings";
+import { isUncommitted } from "./blame";
+import { repoOf, statusOf, useVcs } from "./store";
+
+export function relativeBlameDate(timeMs: number | null, now = Date.now()): string {
+ if (timeMs === null) return "";
+ const seconds = Math.max(0, (now - timeMs) / 1000);
+ const units = [
+ ["year", 365 * 86400],
+ ["month", 30 * 86400],
+ ["day", 86400],
+ ["hour", 3600],
+ ["minute", 60],
+ ] as const;
+ const unit = units.find(([, size]) => seconds >= size);
+ return unit
+ ? new Intl.RelativeTimeFormat(useI18n.getState().locale, { numeric: "always" }).format(
+ -Math.floor(seconds / unit[1]),
+ unit[0],
+ )
+ : tx("now");
+}
+
+export function formatInlineBlame(line: BlameLine, now = Date.now()): string {
+ if (isUncommitted(line)) return tx("You, now · Uncommitted changes");
+ const date = relativeBlameDate(line.timeMs, now);
+ return `${line.author}${date ? `, ${date}` : ""} · ${line.summary.replace(/\s+/g, " ")}`;
+}
+
+/** Only the current document version is retained, including its in-flight request. */
+class BlameCache {
+ private doc: Text | undefined;
+ private pending: Promise<BlameLine[]> | undefined;
+
+ clear() {
+ this.doc = undefined;
+ this.pending = undefined;
+ }
+
+ get(doc: Text, load: () => Promise<BlameLine[]>): Promise<BlameLine[]> {
+ if (doc !== this.doc || !this.pending) {
+ this.doc = doc;
+ this.pending = load();
+ }
+ return this.pending;
+ }
+}
+
+class BlameWidget extends WidgetType {
+ constructor(readonly line: BlameLine) {
+ super();
+ }
+
+ eq(other: BlameWidget) {
+ return formatInlineBlame(other.line) === formatInlineBlame(this.line) && other.line.commit === this.line.commit;
+ }
+
+ toDOM() {
+ const el = document.createElement("span");
+ el.className = "cm-vcs-inline-blame";
+ el.textContent = formatInlineBlame(this.line);
+ el.contentEditable = "false";
+ if (!isUncommitted(this.line)) {
+ el.setAttribute("role", "button");
+ el.tabIndex = 0;
+ const open = () => void executeAction("vcs.showCommit", this.line.commit);
+ el.addEventListener("mousedown", (e) => e.preventDefault());
+ el.addEventListener("click", open);
+ el.addEventListener("keydown", (e) => {
+ if (e.key === "Enter" || e.key === " ") {
+ e.preventDefault();
+ open();
+ }
+ });
+ }
+ return el;
+ }
+}
+
+const setInlineBlame = StateEffect.define<DecorationSet>();
+const inlineBlameField = StateField.define<DecorationSet>({
+ create: () => Decoration.none,
+ update(value, tr) {
+ if (tr.docChanged || tr.selection) return Decoration.none;
+ for (const effect of tr.effects) if (effect.is(setInlineBlame)) return effect.value;
+ return value;
+ },
+ provide: (field) => EditorView.decorations.from(field),
+});
+
+export function inlineBlame(ctx: EditorDocContext): Extension {
+ if (ctx.virtual || ctx.readOnly) return [];
+ const plugin = ViewPlugin.fromClass(
+ class {
+ private timer: ReturnType<typeof setTimeout> | undefined;
+ private readonly cache = new BlameCache();
+ private readonly messages = new Map<string, Promise<string>>();
+ private readonly off: (() => void)[];
+ private generation = 0;
+ private destroyed = false;
+ line: BlameLine | undefined;
+
+ constructor(readonly view: EditorView) {
+ this.off = [
+ useVcs.subscribe((s, prev) => {
+ if (s.version !== prev.version) this.invalidate();
+ }),
+ onEditorEvent((e) => {
+ if (e.type === "docSaved" && e.path === ctx.path) this.invalidate();
+ }),
+ onWorkflowSettingsChange(
+ (s) => s.vcs.git.inlineBlame,
+ () => this.invalidate(),
+ ),
+ useI18n.subscribe(() => this.invalidate()),
+ ];
+ this.schedule();
+ }
+
+ private enabled() {
+ const vcs = useVcs.getState();
+ const status = statusOf(ctx.path);
+ return (
+ workflowSettings().vcs.git.inlineBlame &&
+ isTauri() &&
+ vcs.available &&
+ vcs.statusLoaded &&
+ !!repoOf(ctx.path) &&
+ status?.unstaged !== "untracked" &&
+ status?.unstaged !== "ignored" &&
+ this.view.state.doc.length <= HEAVY_LIMIT
+ );
+ }
+
+ private clear() {
+ this.line = undefined;
+ if (this.view.state.field(inlineBlameField).size)
+ this.view.dispatch({ effects: setInlineBlame.of(Decoration.none) });
+ }
+
+ private invalidate() {
+ this.cache.clear();
+ this.clear();
+ this.schedule();
+ }
+
+ update(update: ViewUpdate) {
+ if (update.docChanged) this.cache.clear();
+ if (update.docChanged || update.selectionSet) {
+ this.line = undefined;
+ this.schedule();
+ }
+ }
+
+ private schedule() {
+ clearTimeout(this.timer);
+ ++this.generation;
+ this.timer = setTimeout(() => void this.refresh(), 300);
+ }
+
+ private async refresh() {
+ if (this.destroyed || !this.enabled()) return;
+ const { doc, selection } = this.view.state;
+ const caret = doc.lineAt(selection.main.head);
+ if (doc.lineAt(selection.main.from).number !== doc.lineAt(selection.main.to).number) return;
+ const generation = this.generation;
+ try {
+ const lines = await this.cache.get(doc, async () => {
+ // Blame also returns synthetic entries for paths absent from HEAD (ignored / new files).
+ if ((await call(commands.vcsFileAt(ctx.path, "HEAD"))) === null) return [];
+ return call(commands.vcsBlame(ctx.path, doc.toString(), null));
+ });
+ if (this.destroyed || generation !== this.generation || doc !== this.view.state.doc || !this.enabled())
+ return;
+ this.line = lines[caret.number - 1];
+ if (this.line) {
+ const widget = Decoration.widget({ widget: new BlameWidget(this.line), side: 1 }).range(caret.to);
+ this.view.dispatch({ effects: setInlineBlame.of(Decoration.set([widget])) });
+ }
+ } catch {
+ // Repository removed, unborn HEAD, inaccessible file, etc.: leave the line undecorated.
+ }
+ }
+
+ message(line: BlameLine): Promise<string> {
+ if (isUncommitted(line)) return Promise.resolve(tx("You, now · Uncommitted changes"));
+ let message = this.messages.get(line.commit);
+ if (!message) {
+ message = call(
+ commands.vcsLog(repoOf(ctx.path), {
+ branch: line.commit,
+ path: null,
+ author: null,
+ text: null,
+ skip: 0,
+ limit: 1,
+ }),
+ ).then(
+ (commits) => commits[0]?.message ?? line.summary,
+ () => line.summary,
+ );
+ if (this.messages.size >= 100) this.messages.delete(this.messages.keys().next().value!);
+ this.messages.set(line.commit, message);
+ }
+ return message;
+ }
+
+ destroy() {
+ this.destroyed = true;
+ clearTimeout(this.timer);
+ this.cache.clear();
+ this.off.forEach((off) => off());
+ }
+ },
+ );
+ return [
+ inlineBlameField,
+ plugin,
+ hoverTooltip(
+ async (view, pos, side) => {
+ const instance = view.plugin(plugin);
+ const line = instance?.line;
+ const end = view.state.doc.lineAt(view.state.selection.main.head).to;
+ if (!instance || !line || pos !== end || side < 0) return null;
+ const message = await instance.message(line);
+ if (view.plugin(plugin)?.line !== line) return null;
+ return {
+ pos: end,
+ above: true,
+ create() {
+ const dom = document.createElement("div");
+ dom.className = "cm-vcs-inline-blame-tooltip";
+ dom.textContent = isUncommitted(line)
+ ? message
+ : `${line.author}\n${line.timeMs === null ? "" : new Date(line.timeMs).toLocaleString()}\n${line.commit}\n\n${message}`;
+ return { dom };
+ },
+ };
+ },
+ {
+ hideOnChange: true,
+ hideOn: (tr) => tr.effects.some((effect) => effect.is(setInlineBlame)),
+ },
+ ),
+ EditorView.baseTheme({
+ ".cm-vcs-inline-blame": {
+ color: "var(--fg-inlay)",
+ marginLeft: "3ch",
+ display: "inline-block",
+ maxWidth: "min(60ch, 50vw)",
+ overflow: "hidden",
+ textOverflow: "ellipsis",
+ whiteSpace: "nowrap",
+ verticalAlign: "bottom",
+ userSelect: "none",
+ },
+ '.cm-vcs-inline-blame[role="button"]': { cursor: "pointer" },
+ ".cm-vcs-inline-blame-tooltip": {
+ padding: "8px 12px",
+ maxWidth: "min(70ch, 80vw)",
+ whiteSpace: "pre-wrap",
+ overflowWrap: "anywhere",
+ },
+ }),
+ ];
+}
diff --git a/src/platform/clientSettings.ts b/src/platform/clientSettings.ts
index b2c2c83b0..742e797d0 100644
--- a/src/platform/clientSettings.ts
+++ b/src/platform/clientSettings.ts
@@ -77,6 +77,7 @@ export const CLIENT_SETTINGS_KEYS = [
"run.confirmTerminate",
"run.showOnStart",
"vcs.showDirtyDirectories",
+ "vcs.git.inlineBlame",
"vcs.git.showPushDialog",
"vcs.git.pushDialogOnlyProtected",
"vcs.git.combineStashAndShelf",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 811644d75..844d50811 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5497,5 +5497,8 @@
"Cannot paste image": "无法粘贴图片",
"Remote server does not support image paste.": "远程服务器不支持粘贴图片。",
"Clipboard image reading is unavailable.": "无法读取剪贴板图片。",
- "Image is too large to paste (limit {limit} MB).": "图片过大,无法粘贴(上限 {limit} MB)。"
+ "Image is too large to paste (limit {limit} MB).": "图片过大,无法粘贴(上限 {limit} MB)。",
+ "Show inline blame for the current line": "为当前行显示内联 Git Blame",
+ "You, now · Uncommitted changes": "你,刚刚 · 未提交的更改",
+ "now": "刚刚"
}
diff --git a/src/platform/workflowSettings.test.ts b/src/platform/workflowSettings.test.ts
index 1721e2ca7..d12da7d58 100644
--- a/src/platform/workflowSettings.test.ts
+++ b/src/platform/workflowSettings.test.ts
@@ -3,6 +3,12 @@ import { splitCommandLine } from "./commandLine";
import { DEFAULT_WORKFLOW, validateWorkflow } from "./workflowSettings";
describe("validateWorkflow", () => {
+ it("defaults inline blame off and accepts only boolean values", () => {
+ expect(DEFAULT_WORKFLOW.vcs.git.inlineBlame).toBe(false);
+ expect(validateWorkflow({ vcs: { git: { inlineBlame: true } } }).vcs.git.inlineBlame).toBe(true);
+ expect(validateWorkflow({ vcs: { git: { inlineBlame: "true" } } }).vcs.git.inlineBlame).toBe(false);
+ });
+
it("falls back to defaults for missing or malformed values", () => {
expect(validateWorkflow(undefined)).toEqual(DEFAULT_WORKFLOW);
const v = validateWorkflow({
diff --git a/src/platform/workflowSettings.ts b/src/platform/workflowSettings.ts
index 428714803..559d20d9b 100644
--- a/src/platform/workflowSettings.ts
+++ b/src/platform/workflowSettings.ts
@@ -18,6 +18,7 @@ export interface IssueLinkValid {
}
export interface GitSettingsValid {
+ inlineBlame: boolean;
executable: string;
updateMethod: UpdateMethod;
autoUpdateOnPushRejected: boolean;
@@ -183,6 +184,7 @@ export const DEFAULT_WORKFLOW: WorkflowSettings = {
limitHistory: true,
historyLimit: 1000,
git: {
+ inlineBlame: false,
executable: "",
updateMethod: "merge",
autoUpdateOnPushRejected: false,
@@ -309,6 +311,7 @@ export function validateVcs(raw: unknown): VcsSettingsValid {
limitHistory: bool(v.limitHistory, d.limitHistory),
historyLimit: num(v.historyLimit, d.historyLimit, L.historyLimit, true),
git: {
+ inlineBlame: bool(g.inlineBlame, d.git.inlineBlame),
executable: text(g.executable, d.git.executable).trim(),
updateMethod: oneOf(g.updateMethod, ["merge", "rebase"] as const, d.git.updateMethod),
autoUpdateOnPushRejected: bool(g.autoUpdateOnPushRejected, d.git.autoUpdateOnPushRejected),