@theia/scm 1.75.0-next.8 → 1.75.0

package/src/browser/scm-history-graph-model.ts

@@ -14,25 +14,47 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
-import { Emitter } from '@theia/core/lib/common/event';
+import { Emitter, Event } from '@theia/core/lib/common/event';
 import { CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { ScmService } from './scm-service';
-import { ScmHistoryItem, ScmHistoryProvider, ScmHistoryOptions } from './scm-provider';
+import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryProvider, ScmHistoryOptions } from './scm-provider';
 import { computeGraphRows, GraphRow } from './scm-history-graph-lanes';
+import { ILogger } from '@theia/core';
+import { getRefColorIndex } from './scm-history-graph-helpers';
+import { ScmPreferences } from '../common/scm-preferences';
 
 export const PAGE_SIZE = 50;
 
+/** How the changes of an expanded history item are laid out. */
+export type ScmHistoryViewMode = 'list' | 'tree';
+
+export const ScmHistoryGraphModelProvider = Symbol('ScmHistoryGraphModelProvider');
+/**
+ * Resolves the {@link ScmHistoryGraphModel} singleton on first use. The model
+ * starts loading history and subscribing to provider events as soon as it is
+ * instantiated, so clients that may not need it (e.g. command contributions
+ * instantiated at application start) must inject this provider instead of the
+ * model itself.
+ */
+export type ScmHistoryGraphModelProvider = () => ScmHistoryGraphModel;
+
 export interface HistoryGraphEntry {
     readonly item: ScmHistoryItem;
     readonly graphRow: GraphRow;
+    /** True when this item is the commit the current history item ref points at (HEAD). */
+    readonly isCurrent: boolean;
 }
 
 @injectable()
 export class ScmHistoryGraphModel {
 
     @inject(ScmService) protected readonly scmService: ScmService;
+    @inject(ScmPreferences) protected readonly scmPreferences: ScmPreferences;
+
+    @inject(ILogger) @named('scm:ScmHistoryGraphModel')
+    protected readonly logger: ILogger;
 
     protected readonly toDispose = new DisposableCollection();
     protected readonly toDisposeOnProviderChange = new DisposableCollection();
@@ -42,10 +64,17 @@ export class ScmHistoryGraphModel {
     protected _loading = false;
     protected _hasAttemptedLoad = false;
     protected _provider: ScmHistoryProvider | undefined;
+    /** Explicitly picked ref ids to filter the graph by; `undefined` = auto (current/remote/base). */
+    protected _historyItemRefFilter: string[] | undefined;
+    protected _viewMode: ScmHistoryViewMode = 'list';
 
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
 
+    protected readonly onDidRequestRevealEmitter = new Emitter<number>();
+    /** Fired with the index of an entry the view should scroll to and select. */
+    readonly onDidRequestReveal: Event<number> = this.onDidRequestRevealEmitter.event;
+
     protected cancelSource = new CancellationTokenSource();
 
     @postConstruct()
@@ -53,7 +82,13 @@ export class ScmHistoryGraphModel {
         this.toDispose.pushAll([
             Disposable.create(() => this.toDisposeOnProviderChange.dispose()),
             this.onDidChangeEmitter,
+            this.onDidRequestRevealEmitter,
             this.scmService.onDidChangeSelectedRepository(() => this.refresh()),
+            this.scmPreferences.onPreferenceChanged(e => {
+                if (e.preferenceName === 'scm.graph.pageSize') {
+                    this.reload();
+                }
+            }),
         ]);
         this.refresh();
     }
@@ -67,6 +102,49 @@ export class ScmHistoryGraphModel {
         return this._provider;
     }
 
+    /** The explicitly picked ref ids filtering the graph, or `undefined` in auto mode. */
+    get historyItemRefFilter(): readonly string[] | undefined {
+        return this._historyItemRefFilter;
+    }
+
+    /** How the changes of an expanded history item are laid out. */
+    get viewMode(): ScmHistoryViewMode {
+        return this._viewMode;
+    }
+
+    /**
+     * Switches how the changes of an expanded history item are laid out. This
+     * only affects rendering, so the loaded history is kept as is.
+     */
+    setViewMode(viewMode: ScmHistoryViewMode): void {
+        if (this._viewMode === viewMode) {
+            return;
+        }
+        this._viewMode = viewMode;
+        this.onDidChangeEmitter.fire();
+    }
+
+    /**
+     * Sets the ref ids to filter the graph by (`undefined` returns to auto
+     * mode) and reloads the graph.
+     */
+    setHistoryItemRefFilter(refIds: readonly string[] | undefined): void {
+        this._historyItemRefFilter = refIds && refIds.length > 0 ? [...refIds] : undefined;
+        this.reload();
+    }
+
+    /**
+     * Whether the current history item ref is part of the graph's filter.
+     * Always true in auto mode, which includes the current ref.
+     */
+    isCurrentRefInFilter(): boolean {
+        if (!this._historyItemRefFilter) {
+            return true;
+        }
+        const currentId = this._provider?.currentHistoryItemRef?.id;
+        return currentId !== undefined && this._historyItemRefFilter.includes(currentId);
+    }
+
     get entries(): readonly HistoryGraphEntry[] {
         return this._entries;
     }
@@ -89,13 +167,14 @@ export class ScmHistoryGraphModel {
     }
 
     refresh(): void {
-        this.cancelSource.cancel();
-        this.cancelSource = new CancellationTokenSource();
-
         this.toDisposeOnProviderChange.dispose();
 
         const repo = this.scmService.selectedRepository;
         const hp = repo?.provider.historyProvider;
+        if (hp !== this._provider) {
+            // The repository changed — a filter picked for the old provider does not apply.
+            this._historyItemRefFilter = undefined;
+        }
         this._provider = hp;
 
         if (this._provider) {
@@ -103,7 +182,10 @@ export class ScmHistoryGraphModel {
                 this._provider.onDidChangeCurrentHistoryItemRefs(() => this.refresh())
             );
             this.toDisposeOnProviderChange.push(
-                this._provider.onDidChangeHistoryItemRefs(() => this.refresh())
+                this._provider.onDidChangeHistoryItemRefs(e => {
+                    this.pruneHistoryItemRefFilter(e.removed);
+                    this.refresh();
+                })
             );
         } else if (repo) {
             // historyProvider is not yet available; listen for provider changes
@@ -113,12 +195,66 @@ export class ScmHistoryGraphModel {
             );
         }
 
+        this.reload();
+    }
+
+    /**
+     * Drops refs that no longer exist from the explicit filter, so that
+     * deleting or renaming a filtered ref does not leave the graph stuck
+     * requesting history for it. When the last filtered ref is removed,
+     * the filter falls back to auto mode.
+     */
+    protected pruneHistoryItemRefFilter(removed: readonly ScmHistoryItemRef[]): void {
+        if (!this._historyItemRefFilter || removed.length === 0) {
+            return;
+        }
+        const removedIds = new Set(removed.map(ref => ref.id));
+        const remaining = this._historyItemRefFilter.filter(id => !removedIds.has(id));
+        if (remaining.length !== this._historyItemRefFilter.length) {
+            this._historyItemRefFilter = remaining.length > 0 ? remaining : undefined;
+        }
+    }
+
+    /** Clears the loaded entries and loads the first page again from the current provider. */
+    protected reload(): void {
+        this.cancelSource.cancel();
+        this.cancelSource = new CancellationTokenSource();
+
         this._entries = [];
         this._hasMore = false;
 
         this.loadPage();
     }
 
+    /**
+     * Locates the commit the current history item ref points at, loading
+     * further pages while it is outside the loaded range, and asks the view to
+     * reveal it. Returns its index, or `undefined` when there is no current
+     * history item ref or the commit is not part of the graph (e.g. the ref is
+     * excluded by the filter).
+     */
+    async revealCurrentHistoryItem(): Promise<number | undefined> {
+        let index = this.indexOfCurrentHistoryItem();
+        while (index === undefined && this._hasMore) {
+            const loadedBefore = this._entries.length;
+            await this.loadMore();
+            if (this._entries.length === loadedBefore) {
+                // The page added nothing new; paging further cannot find the item.
+                break;
+            }
+            index = this.indexOfCurrentHistoryItem();
+        }
+        if (index !== undefined) {
+            this.onDidRequestRevealEmitter.fire(index);
+        }
+        return index;
+    }
+
+    protected indexOfCurrentHistoryItem(): number | undefined {
+        const index = this._entries.findIndex(entry => entry.isCurrent);
+        return index === -1 ? undefined : index;
+    }
+
     async loadMore(): Promise<void> {
         if (this._loading || !this._hasMore) {
             return;
@@ -141,10 +277,11 @@ export class ScmHistoryGraphModel {
 
         const token = this.cancelSource.token;
         try {
+            const pageSize = this.pageSize;
             const historyItemRefs = this.getCurrentHistoryItemRefs();
             const options: ScmHistoryOptions = {
                 skip: this._entries.length,
-                limit: PAGE_SIZE,
+                limit: pageSize,
                 historyItemRefs: historyItemRefs.length > 0 ? historyItemRefs : undefined,
             };
             const items = await this._provider.provideHistoryItems(options, token);
@@ -154,7 +291,7 @@ export class ScmHistoryGraphModel {
             }
 
             const fetchedItems: ScmHistoryItem[] = items ?? [];
-            this._hasMore = fetchedItems.length >= PAGE_SIZE;
+            this._hasMore = fetchedItems.length >= pageSize;
 
             // Filter out any items already loaded so the graph does not show duplicates.
             const existingIds = new Set(this._entries.map(e => e.item.id));
@@ -164,15 +301,18 @@ export class ScmHistoryGraphModel {
             const graphRows = computeGraphRows(allItems.map(i => ({
                 id: i.id,
                 parentIds: i.parentIds,
+                colorIndex: this.resolveColorIndex(i),
             })));
 
+            const currentRevision = this._provider.currentHistoryItemRef?.revision;
             this._entries = allItems.map((item, idx) => ({
                 item,
                 graphRow: graphRows[idx],
+                isCurrent: currentRevision !== undefined && item.id === currentRevision,
             }));
         } catch (err) {
             if (!token.isCancellationRequested) {
-                console.error('ScmHistoryGraphModel: failed to load history', err);
+                this.logger.error('Failed to load history', err);
             }
         } finally {
             if (!token.isCancellationRequested) {
@@ -183,12 +323,40 @@ export class ScmHistoryGraphModel {
         }
     }
 
+    /** The configured page size (`scm.graph.pageSize`). */
+    protected get pageSize(): number {
+        return this.scmPreferences['scm.graph.pageSize'] ?? PAGE_SIZE;
+    }
+
+    /**
+     * Resolves the ref-based color index of an item from its references,
+     * preferring current (0) over remote (1) over base (2). Refs excluded by
+     * an explicit filter get no role color, mirroring VS Code's color map.
+     */
+    protected resolveColorIndex(item: ScmHistoryItem): number | undefined {
+        let result: number | undefined;
+        for (const ref of item.references ?? []) {
+            if (this._historyItemRefFilter && !this._historyItemRefFilter.includes(ref.id)) {
+                continue;
+            }
+            const index = getRefColorIndex(ref, this._provider);
+            if (index !== undefined && (result === undefined || index < result)) {
+                result = index;
+            }
+        }
+        return result;
+    }
+
     /**
-     * Returns the revisions of the current branch ref, its remote tracking ref,
-     * and the merge-base ref to pass to `provideHistoryItems`. Providers walk
-     * history starting from these revisions.
+     * Returns the refs to pass to `provideHistoryItems`: the explicitly picked
+     * ref ids when a filter is active, otherwise (auto mode) the revisions of
+     * the current branch ref, its remote tracking ref, and the merge-base ref.
+     * Providers walk history starting from these refs.
      */
     protected getCurrentHistoryItemRefs(): string[] {
+        if (this._historyItemRefFilter) {
+            return [...this._historyItemRefFilter];
+        }
         if (!this._provider) {
             return [];
         }

package/src/browser/scm-history-graph-tooltip.spec.ts

@@ -0,0 +1,254 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { MarkdownRenderer } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
+import { MarkdownString, MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering/markdown-string';
+import { OpenerService } from '@theia/core/lib/browser/opener-service';
+import { markMarkdownLinksWired } from '@theia/core/lib/browser/markdown-rendering/markdown-link-handler';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import URI from '@theia/core/lib/common/uri';
+import { ScmHistoryItem } from './scm-provider';
+import { HistoryGraphEntry } from './scm-history-graph-model';
+import { buildHtmlTooltip, buildProviderTooltip, HistoryTooltipActions } from './scm-history-graph-tooltip';
+
+disableJSDOM();
+
+function makeEntry(item: Partial<ScmHistoryItem>): HistoryGraphEntry {
+    return {
+        item: {
+            id: '1a56ba96fdc9b6df3a230df7b44e22e5785e3abd',
+            subject: 'fix something',
+            parentIds: [],
+            ...item,
+        },
+        graphRow: { lane: 0, color: 0, topColor: 0, edges: [], hasContinuation: false, hasTopLine: false },
+        isCurrent: false,
+    };
+}
+
+const markdownRenderer = {
+    render: () => ({ element: document.createElement('div'), dispose: () => { } })
+} as unknown as MarkdownRenderer;
+
+describe('buildHtmlTooltip', () => {
+    let restoreJSDOM: () => void;
+
+    before(() => {
+        restoreJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        restoreJSDOM();
+    });
+
+    it('renders the author as a bold mailto link when the email is known', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe', authorEmail: 'jane@example.com', timestamp: 1000 }), markdownRenderer);
+        const link = tooltip.querySelector('a[href="mailto:jane@example.com"]');
+        expect(link, 'mailto link').to.not.be.null;
+        expect(link!.textContent).to.contain('Jane Doe');
+        expect(link!.querySelector('strong'), 'bold author').to.not.be.null;
+    });
+
+    it('renders a plain bold author when no email is known', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe', timestamp: 1000 }), markdownRenderer);
+        expect(tooltip.querySelector('a[href^="mailto:"]')).to.be.null;
+        const strong = tooltip.querySelector('.scm-history-tooltip-header strong');
+        expect(strong).to.not.be.null;
+        expect(strong!.textContent).to.equal('Jane Doe');
+    });
+
+    it('renders the author avatar image when authorIcon is a URL', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe', authorIcon: 'https://avatars.example.com/u/1' }), markdownRenderer);
+        const img = tooltip.querySelector('img.scm-history-tooltip-avatar') as HTMLImageElement;
+        expect(img, 'avatar image').to.not.be.null;
+        expect(img.src).to.equal('https://avatars.example.com/u/1');
+    });
+
+    it('falls back to the account icon without an avatar', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe' }), markdownRenderer);
+        expect(tooltip.querySelector('img.scm-history-tooltip-avatar')).to.be.null;
+        expect(tooltip.querySelector('.scm-history-tooltip-header .codicon-account')).to.not.be.null;
+    });
+
+    it('renders an Open Commit action with the short hash', () => {
+        let opened = 0;
+        const actions: HistoryTooltipActions = { openCommit: () => { opened++; } };
+        const tooltip = buildHtmlTooltip(makeEntry({ displayId: '1a56ba9' }), markdownRenderer, undefined, actions);
+        const action = tooltip.querySelector('[title="Open Commit"]') as HTMLElement;
+        expect(action, 'open commit action').to.not.be.null;
+        expect(action.textContent).to.contain('1a56ba9');
+        action.click();
+        expect(opened).to.equal(1);
+    });
+
+    it('renders a Copy Commit Hash action', () => {
+        let copied = 0;
+        const actions: HistoryTooltipActions = { copyCommitHash: () => { copied++; } };
+        const tooltip = buildHtmlTooltip(makeEntry({}), markdownRenderer, undefined, actions);
+        const action = tooltip.querySelector('[title="Copy Commit Hash"]') as HTMLElement;
+        expect(action, 'copy hash action').to.not.be.null;
+        action.click();
+        expect(copied).to.equal(1);
+    });
+
+    it('shows the short hash as plain text when no actions are given', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ displayId: '1a56ba9' }), markdownRenderer);
+        expect(tooltip.querySelector('[title="Open Commit"]')).to.be.null;
+        expect(tooltip.querySelector('[title="Copy Commit Hash"]')).to.be.null;
+        expect(tooltip.textContent).to.contain('1a56ba9');
+    });
+});
+
+describe('buildProviderTooltip', () => {
+    let restoreJSDOM: () => void;
+    let opened: string[];
+    let toDispose: DisposableCollection;
+
+    /** Renders the markdown value as HTML, so that the wiring of the resulting links can be asserted. */
+    const htmlRenderer = {
+        render: (markdown: MarkdownString) => {
+            const element = document.createElement('div');
+            element.innerHTML = markdown.value;
+            return { element, dispose: () => { } };
+        }
+    } as unknown as MarkdownRenderer;
+
+    const openerService = {
+        getOpener: (uri: URI) => Promise.resolve({
+            canHandle: () => 1,
+            open: () => {
+                // decoded, as `HttpOpenHandler` does when opening the target externally
+                opened.push(uri.toString(true));
+                return Promise.resolve(undefined);
+            }
+        })
+    } as unknown as OpenerService;
+
+    /** Clicks the anchor and waits for the asynchronous opener lookup to settle. */
+    async function click(tooltip: HTMLElement, selector: string): Promise<void> {
+        const anchor = tooltip.querySelector(selector) as HTMLElement;
+        expect(anchor, selector).to.not.be.null;
+        anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+    }
+
+    before(() => {
+        restoreJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        restoreJSDOM();
+    });
+
+    beforeEach(() => {
+        opened = [];
+        toDispose = new DisposableCollection();
+    });
+
+    afterEach(() => {
+        toDispose.dispose();
+    });
+
+    it('renders each section in order', () => {
+        const tooltip = buildProviderTooltip(
+            [new MarkdownStringImpl('<span>first</span>'), new MarkdownStringImpl('<span>second</span>')],
+            htmlRenderer, openerService, toDispose)!;
+        expect(tooltip, 'tooltip').to.not.be.undefined;
+        expect(tooltip.textContent).to.equal('firstsecond');
+    });
+
+    // `vscode.git` ends its author and statistics sections with a horizontal rule of its own,
+    // so adding separators here would render every boundary as a double line.
+    it('adds no separators of its own between sections', () => {
+        const tooltip = buildProviderTooltip(
+            [new MarkdownStringImpl('<span>first</span><hr>'), new MarkdownStringImpl('<span>second</span>')],
+            htmlRenderer, openerService, toDispose)!;
+        expect(tooltip.querySelectorAll('hr').length, 'rules').to.equal(1);
+    });
+
+    it('renders a plain string tooltip', () => {
+        const tooltip = buildProviderTooltip('just text', htmlRenderer, openerService, toDispose)!;
+        expect(tooltip, 'tooltip').to.not.be.undefined;
+        expect(tooltip.textContent).to.equal('just text');
+    });
+
+    it('returns undefined when the provider supplies no usable content', () => {
+        expect(buildProviderTooltip('   ', htmlRenderer, openerService, toDispose)).to.be.undefined;
+        expect(buildProviderTooltip([], htmlRenderer, openerService, toDispose)).to.be.undefined;
+    });
+
+    it('routes an author mailto link through the opener service', async () => {
+        const tooltip = buildProviderTooltip(
+            new MarkdownStringImpl('<a href="mailto:jane@example.com">Jane Doe</a>'), htmlRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="mailto:"]');
+        expect(opened).to.deep.equal(['mailto:jane@example.com']);
+    });
+
+    it('executes a command link that the section trusts', async () => {
+        const section = new MarkdownStringImpl('<a href="command:git.viewCommit">Open Commit</a>');
+        section.isTrusted = { enabledCommands: ['git.viewCommit'] };
+        const tooltip = buildProviderTooltip(section, htmlRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="command:"]');
+        expect(opened).to.deep.equal(['command:git.viewCommit']);
+    });
+
+    it('blocks a command link that the section does not trust', async () => {
+        const section = new MarkdownStringImpl('<a href="command:git.viewCommit">Open Commit</a>');
+        section.isTrusted = { enabledCommands: ['git.copyContentToClipboard'] };
+        const tooltip = buildProviderTooltip(section, htmlRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="command:"]');
+        expect(opened).to.be.empty;
+    });
+
+    it('does not open a link twice when the renderer already wired it', async () => {
+        // The Monaco-based renderer used at runtime routes link activation through the opener
+        // service itself, so wiring a second handler on top would open every link twice.
+        const wiringRenderer = {
+            render: (markdown: MarkdownString) => {
+                const element = document.createElement('div');
+                element.innerHTML = markdown.value;
+                markMarkdownLinksWired(element);
+                element.addEventListener('click', event => {
+                    event.preventDefault();
+                    opened.push((event.target as HTMLElement).getAttribute('href')!);
+                });
+                return { element, dispose: () => { } };
+            }
+        } as unknown as MarkdownRenderer;
+
+        const section = new MarkdownStringImpl('<a href="command:git.viewCommit">Open Commit</a>');
+        section.isTrusted = { enabledCommands: ['git.viewCommit'] };
+        const tooltip = buildProviderTooltip(section, wiringRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="command:"]');
+        expect(opened).to.deep.equal(['command:git.viewCommit']);
+    });
+
+    it('does not let one section authorize another section\'s commands', async () => {
+        const untrusted = new MarkdownStringImpl('<a id="untrusted" href="command:git.viewCommit">Open Commit</a>');
+        const trusted = new MarkdownStringImpl('<a id="trusted" href="command:git.copyContentToClipboard">Copy</a>');
+        trusted.isTrusted = { enabledCommands: ['git.copyContentToClipboard'] };
+        const tooltip = buildProviderTooltip([untrusted, trusted], htmlRenderer, openerService, toDispose)!;
+
+        await click(tooltip, 'a#untrusted');
+        expect(opened, 'untrusted section').to.be.empty;
+        await click(tooltip, 'a#trusted');
+        expect(opened, 'trusted section').to.deep.equal(['command:git.copyContentToClipboard']);
+    });
+});