@theia/workspace 1.77.0-next.6 → 1.77.0-next.63

package/src/browser/workspace-service.ts

@@ -16,6 +16,7 @@
 
 import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
+import { Path } from '@theia/core/lib/common/path';
 import { WorkspaceServer, UntitledWorkspaceService, WorkspaceFileService } from '../common';
 import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import { DEFAULT_WINDOW_HASH } from '@theia/core/lib/common/window';
@@ -25,7 +26,7 @@ import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { ILogger, Disposable, DisposableCollection, Emitter, environment, Event, MaybePromise, MessageService, nls, ContributionProvider } from '@theia/core';
 import { WorkspacePreferences } from '../common/workspace-preferences';
 import * as jsoncparser from 'jsonc-parser';
-import * as Ajv from '@theia/core/shared/ajv';
+import Ajv from '@theia/core/shared/ajv';
 import { FileStat, BaseStat } from '@theia/filesystem/lib/common/files';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { WindowTitleService } from '@theia/core/lib/browser/window/window-title-service';
@@ -312,6 +313,7 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
         }
         if (rootsChanged) {
             this._roots = newRoots;
+            this.rootNamesCache = undefined;
             this.deferredRoots.resolve(this._roots); // in order to resolve first
             this.deferredRoots = new Deferred<FileStat[]>();
             this.deferredRoots.resolve(this._roots);
@@ -596,6 +598,7 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
             this.windowService.setSafeToShutDown();
             this._workspace = undefined;
             this._roots.length = 0;
+            this.rootNamesCache = undefined;
 
             if (!this.isRemoteSession()) {
                 await this.server.setMostRecentlyUsedWorkspace('');
@@ -833,7 +836,7 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
         if (!rootUri) {
             return uri.path.fsPath();
         }
-        const rootName = rootUri.path.base;
+        const rootName = this.getRootName(rootUri) ?? rootUri.path.base;
         const relative = rootUri.relative(uri);
         if (!relative || relative.toString() === '') {
             return rootName;
@@ -841,6 +844,217 @@ export class WorkspaceService implements FrontendApplicationContribution, Worksp
         return `${rootName}/${relative.toString()}`;
     }
 
+    /**
+     * Returns a unique name for each workspace root, in workspace order.
+     *
+     * A root is named after its directory basename, e.g. `backend`. Roots that share a basename are
+     * treated as peers: each of them is named after the shortest tail of its path that tells them
+     * apart, e.g. `alice/app` and `bob/app`. A name that another name starts with, e.g. `alice` next to
+     * `alice/app`, is qualified in the same way, e.g. `work/alice`, so that every path resolves to the root
+     * it came from. The names are thus always the ending of the real path, so they match what appears in
+     * terminal output, compiler errors and the like.
+     *
+     * These are the root names used by {@link getRootPrefixedPath} and resolved by {@link resolveRootPrefixedPath}.
+     */
+    getRootNames(): ReadonlyMap<string, URI> {
+        return this.getRootNamesCache().names;
+    }
+
+    /**
+     * The root names, and the names by root URI, which depend on each other. Reset whenever the roots change.
+     */
+    protected rootNamesCache: { names: ReadonlyMap<string, URI>; namesByRoot: ReadonlyMap<string, string> } | undefined;
+
+    protected getRootNamesCache(): { names: ReadonlyMap<string, URI>; namesByRoot: ReadonlyMap<string, string> } {
+        if (!this.rootNamesCache) {
+            const names = this.computeRootNames(this.tryGetRoots());
+            const namesByRoot = new Map(Array.from(names, ([name, uri]) => [uri.toString(), name]));
+            this.rootNamesCache = { names, namesByRoot };
+        }
+        return this.rootNamesCache;
+    }
+
+    protected computeRootNames(workspaceRoots: FileStat[]): Map<string, URI> {
+        const roots: URI[] = [];
+        for (const root of workspaceRoots) {
+            if (!roots.some(other => other.isEqual(root.resource))) {
+                roots.push(root.resource);
+            }
+        }
+        const byBasename = new Map<string, URI[]>();
+        for (const root of roots) {
+            const peers = byBasename.get(root.path.base) ?? [];
+            peers.push(root);
+            byBasename.set(root.path.base, peers);
+        }
+        const names = new Map<string, URI>();
+        for (const root of roots) {
+            names.set(this.computeRootName(root, byBasename.get(root.path.base)!), root);
+        }
+        return this.qualifyRootNames(names);
+    }
+
+    /**
+     * Returns the name of the given workspace root, as assigned by {@link getRootNames}, or
+     * `undefined` if the URI is not a workspace root.
+     */
+    getRootName(rootUri: URI): string | undefined {
+        return this.getRootNamesCache().namesByRoot.get(rootUri.toString());
+    }
+
+    /**
+     * Resolves a path in the format of {@link getRootPrefixedPath}, i.e. `<rootName>/<relativePath>`
+     * or a bare `<rootName>`, to a URI. If more than one root name is a prefix of the path, which is
+     * the case when a root named `a` has a subfolder `b` and another root is named `a/b`, the longest
+     * one wins.
+     *
+     * @returns `undefined` if the path is absolute, does not start with a root name or leaves its root.
+     */
+    resolveRootPrefixedPath(rootPrefixedPath: string): URI | undefined {
+        const path = new Path(Path.normalizePathSeparator(rootPrefixedPath)).normalize();
+        if (path.isAbsolute || Path.isDrive(path.toString().split('/')[0])) {
+            return undefined;
+        }
+        const segments = path.toString().split('/').filter(segment => segment.length > 0);
+        if (segments.includes('..')) {
+            return undefined;
+        }
+        const match = this.splitRootPrefixedPath(segments.join('/'));
+        if (!match) {
+            return undefined;
+        }
+        return match.rest ? match.rootUri.resolve(match.rest) : match.rootUri;
+    }
+
+    /**
+     * Resolves a path that contains the basename of a workspace root, preceded by nothing or by the
+     * trailing segments of the root's parent path, e.g. `bob/app/src` for the root `/home/bob/app`.
+     * Unlike {@link resolveRootPrefixedPath}, this does not depend on the current root names, so it
+     * also resolves paths that were prefixed with a root name before the workspace roots changed.
+     *
+     * @returns the distinct candidates in workspace order, which are several if the path is ambiguous,
+     * or none if the path is absolute, leaves its root or does not contain the basename of a root.
+     */
+    resolveSupraRelativePath(supraRelativePath: string): URI[] {
+        const path = new Path(Path.normalizePathSeparator(supraRelativePath)).normalize();
+        const segments = path.toString().split('/').filter(segment => segment.length > 0);
+        if (path.isAbsolute || Path.isDrive(segments[0] ?? '') || segments.includes('..')) {
+            return [];
+        }
+        const candidates: URI[] = [];
+        for (const root of this.tryGetRoots()) {
+            const candidate = this.resolveSupraRelativeSegments(root.resource, segments);
+            if (candidate && !candidates.some(other => other.isEqual(candidate))) {
+                candidates.push(candidate);
+            }
+        }
+        return candidates;
+    }
+
+    /**
+     * Resolves `segments` against the given root as described in {@link resolveSupraRelativePath}.
+     */
+    protected resolveSupraRelativeSegments(rootUri: URI, segments: string[]): URI | undefined {
+        const rootBasename = rootUri.path.base;
+        const rootPathSegments = rootUri.path.toString().split('/').filter(segment => segment.length > 0);
+        const rootPrecedingSegments = rootPathSegments.slice(0, rootPathSegments.length - 1);
+        for (let i = 0; i < segments.length; i++) {
+            if (segments[i] !== rootBasename) {
+                continue;
+            }
+            const pathPrecedingSegments = segments.slice(0, i);
+            if (pathPrecedingSegments.length > rootPrecedingSegments.length) {
+                continue;
+            }
+            const rootTail = rootPrecedingSegments.slice(rootPrecedingSegments.length - pathPrecedingSegments.length);
+            if (pathPrecedingSegments.every((segment, j) => segment === rootTail[j])) {
+                const rest = segments.slice(i + 1).join('/');
+                return rest ? rootUri.resolve(rest) : rootUri;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Splits a `/`-separated path that starts with a root name, as in {@link getRootPrefixedPath}, into
+     * that root and the rest of the path, which is empty for a bare root name. The rest is not normalized,
+     * so it may as well be a glob. If more than one root name is a prefix of the path, the longest one wins.
+     *
+     * @returns `undefined` if the path does not start with a root name.
+     */
+    splitRootPrefixedPath(rootPrefixedPath: string): { rootName: string; rootUri: URI; rest: string } | undefined {
+        const segments = rootPrefixedPath.split('/');
+        let match: { rootName: string; rootUri: URI; length: number } | undefined;
+        for (const [rootName, rootUri] of this.getRootNames()) {
+            const nameSegments = rootName.split('/');
+            const matches = nameSegments.length <= segments.length && nameSegments.every((segment, i) => segment === segments[i]);
+            if (matches && (!match || nameSegments.length > match.length)) {
+                match = { rootName, rootUri, length: nameSegments.length };
+            }
+        }
+        return match && { rootName: match.rootName, rootUri: match.rootUri, rest: segments.slice(match.length).join('/') };
+    }
+
+    /**
+     * Computes the name of a root from the roots that share its basename (including itself).
+     */
+    protected computeRootName(root: URI, peers: URI[]): string {
+        if (peers.length === 1) {
+            return root.path.base || root.path.toString();
+        }
+        const segmentsOf = (uri: URI): string[] => uri.path.toString().split('/').filter(segment => segment.length > 0);
+        const rootSegments = segmentsOf(root);
+        const peerSegments = peers.filter(peer => !peer.isEqual(root)).map(segmentsOf);
+        // A root with a shorter path than a peer, e.g. `/app` next to `/x/app`, is named by its whole path, `app`.
+        const maxLength = Math.max(rootSegments.length, ...peerSegments.map(segments => segments.length));
+        for (let length = 2; length <= maxLength; length++) {
+            const tail = rootSegments.slice(-length).join('/');
+            if (peerSegments.every(segments => segments.slice(-length).join('/') !== tail)) {
+                return tail;
+            }
+        }
+        // The paths are the same, e.g. in different URI schemes, so only the full URI tells them apart.
+        return root.toString();
+    }
+
+    /**
+     * Qualifies a root name that another root name starts with, e.g. `alice` next to `alice/app`, by more
+     * segments of its path, as a path in the one root would otherwise resolve to the other. If the root
+     * named `alice/app` is the `app` folder of the root named `alice`, the names are left as they are:
+     * the nested root is then also the one that {@link getRootPrefixedPath} names its files after.
+     */
+    protected qualifyRootNames(names: Map<string, URI>): Map<string, URI> {
+        const entries = Array.from(names, ([name, root]) => ({ name, root }));
+        let qualified = true;
+        while (qualified) {
+            qualified = false;
+            for (const shorter of entries) {
+                for (const longer of entries) {
+                    if (longer.name.startsWith(shorter.name + '/')
+                        && !shorter.root.resolve(longer.name.substring(shorter.name.length + 1)).isEqual(longer.root)) {
+                        qualified = this.qualifyRootName(shorter) || this.qualifyRootName(longer) || qualified;
+                    }
+                }
+            }
+        }
+        return new Map(entries.map(({ name, root }) => [name, root]));
+    }
+
+    /**
+     * Adds the next parent segment to the name of a root, unless the name is its whole path or its URI already.
+     *
+     * @returns whether the name was qualified
+     */
+    protected qualifyRootName(entry: { name: string; root: URI }): boolean {
+        const segments = entry.root.path.toString().split('/').filter(segment => segment.length > 0);
+        const length = entry.name.split('/').length;
+        if (entry.name === entry.root.toString() || length >= segments.length) {
+            return false;
+        }
+        entry.name = segments.slice(-(length + 1)).join('/');
+        return true;
+    }
+
     areWorkspaceRoots(uris: URI[]): boolean {
         if (!uris.length) {
             return false;

package/src/browser/workspace-uri-contribution.spec.ts

@@ -22,7 +22,7 @@ import * as sinon from 'sinon';
 import { Container } from '@theia/core/shared/inversify';
 import { Event } from '@theia/core/lib/common/event';
 import { ApplicationShell, WidgetManager } from '@theia/core/lib/browser';
-import { DefaultUriLabelProviderContribution } from '@theia/core/lib/browser/label-provider';
+import { DefaultUriLabelProviderContribution, DidChangeLabelEvent } from '@theia/core/lib/browser/label-provider';
 import { WorkspaceUriLabelProviderContribution } from './workspace-uri-contribution';
 import URI from '@theia/core/lib/common/uri';
 import { WorkspaceVariableContribution } from './workspace-variable-contribution';
@@ -40,6 +40,12 @@ after(() => disableJSDOM());
 let container: Container;
 let labelProvider: WorkspaceUriLabelProviderContribution;
 let roots: FileStat[];
+let workspaceService: WorkspaceService;
+/** Changes the roots, as `WorkspaceService.updateRoots` does, which resets their names. */
+const setRoots = (newRoots: FileStat[]): void => {
+    roots = newRoots;
+    workspaceService['rootNamesCache'] = undefined;
+};
 beforeEach(() => {
     roots = [FileStat.dir('file:///workspace')];
 
@@ -53,7 +59,7 @@ beforeEach(() => {
         onDidCreateWidget: Event.None
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } as any);
-    const workspaceService = new WorkspaceService();
+    workspaceService = new WorkspaceService();
     workspaceService.tryGetRoots = () => roots;
     container.bind(WorkspaceService).toConstantValue(workspaceService);
     container.bind(WorkspaceVariableContribution).toSelf().inSingletonScope();
@@ -138,6 +144,42 @@ describe('WorkspaceUriLabelProviderContribution class', () => {
             const name = labelProvider.getName(file);
             expect(name).eq('jacques.doc');
         });
+
+        it('should return the folder name of a workspace root', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/lib')]);
+            expect(labelProvider.getName(FileStat.dir('file:///home/alice/app'))).eq('app');
+        });
+
+        it('should return the unique names of workspace roots sharing a folder name', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/app')]);
+            expect(labelProvider.getName(FileStat.dir('file:///home/alice/app'))).eq('alice/app');
+            expect(labelProvider.getName(new URI('file:///home/bob/app'))).eq('bob/app');
+        });
+
+        it('should return the folder name of a folder that shares its name with a workspace root', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/app')]);
+            expect(labelProvider.getName(FileStat.dir('file:///home/alice/app/app'))).eq('app');
+        });
+
+        it('should notify a change of the name of a workspace root when a root sharing its folder name is added', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/other')]);
+            workspaceService['onWorkspaceChangeEmitter'].fire(roots);
+            const events: DidChangeLabelEvent[] = [];
+            labelProvider.onDidChange(event => events.push(event));
+            setRoots([...roots, FileStat.dir('file:///home/bob/app')]);
+            workspaceService['onWorkspaceChangeEmitter'].fire(roots);
+            expect(events.some(event => event.affects(new URI('file:///home/alice/app')))).to.be.true;
+            expect(events.some(event => event.affects(FileStat.dir('file:///home/alice/app')))).to.be.true;
+            expect(events.some(event => event.affects(new URI('file:///home/other')))).to.be.false;
+            expect(labelProvider.getName(new URI('file:///home/alice/app'))).eq('alice/app');
+        });
+    });
+
+    describe('getDetails()', () => {
+        it('should prefix the path of a file with the unique name of its workspace root', () => {
+            setRoots([FileStat.dir('file:///home/alice/app'), FileStat.dir('file:///home/bob/app')]);
+            expect(labelProvider.getDetails(new URI('file:///home/bob/app/src/index.ts'))).eq('bob/app • src');
+        });
     });
 
     describe('getLongName()', () => {
@@ -176,7 +218,7 @@ describe('WorkspaceUriLabelProviderContribution class', () => {
         });
 
         it('should return the path of a file if WorkspaceService returns no roots', () => {
-            roots = [];
+            setRoots([]);
             const file = new URI('file:///tmp/prout.txt');
             const longName = labelProvider.getLongName(file);
 

package/src/browser/workspace-uri-contribution.ts

@@ -27,9 +27,42 @@ export class WorkspaceUriLabelProviderContribution extends DefaultUriLabelProvid
     @inject(WorkspaceVariableContribution) protected readonly workspaceVariable: WorkspaceVariableContribution;
     @inject(WorkspaceService) protected readonly workspaceService: WorkspaceService;
 
+    /**
+     * The names of the workspace roots by root URI, as last labeled.
+     */
+    protected rootNames = new Map<string, string>();
+
     @postConstruct()
     override init(): void {
-        // no-op, backward compatibility
+        this.rootNames = this.getRootNamesByUri();
+        this.workspaceService.onWorkspaceChanged(() => this.updateRootNames());
+    }
+
+    protected getRootNamesByUri(): Map<string, string> {
+        return new Map(Array.from(this.workspaceService.getRootNames(), ([name, uri]) => [uri.toString(), name]));
+    }
+
+    /**
+     * Notifies a change of the labels of the roots whose names changed, such as a root named `app` that
+     * is named `alice/app` once a root `bob/app` is added.
+     */
+    protected updateRootNames(): void {
+        const rootNames = this.getRootNamesByUri();
+        const changed = new Set<string>();
+        for (const [uri, name] of rootNames) {
+            if (this.rootNames.get(uri) !== name) {
+                changed.add(uri);
+            }
+        }
+        this.rootNames = rootNames;
+        if (changed.size > 0) {
+            this.onDidChangeEmitter.fire({
+                affects: element => {
+                    const uri = this.canHandle(element) > 0 ? this.getUri(element as URI | URIIconReference | FileStat) : undefined;
+                    return !!uri && changed.has(uri.toString());
+                }
+            });
+        }
     }
 
     override canHandle(element: object): number {
@@ -43,7 +76,16 @@ export class WorkspaceUriLabelProviderContribution extends DefaultUriLabelProvid
         return super.getIcon(this.asURIIconReference(element));
     }
 
+    /**
+     * Names a workspace root by its unique name (see {@link WorkspaceService.getRootNames}), so that
+     * roots sharing a folder name can be told apart, e.g. `alice/app` and `bob/app`.
+     */
     override getName(element: URI | URIIconReference | FileStat): string | undefined {
+        const uri = this.getUri(element);
+        const rootName = uri && this.workspaceService.getRootName(uri);
+        if (rootName) {
+            return rootName;
+        }
         return super.getName(this.asURIIconReference(element));
     }