@theia/core 1.58.3 → 1.59.0-next.72

package/src/common/logger.ts

@@ -240,6 +240,8 @@ export class Logger implements ILogger {
     @inject(LoggerFactory) protected readonly factory: LoggerFactory;
     @inject(LoggerName) protected name: string;
 
+    protected cache = new Map<string, ILogger>();
+
     @postConstruct()
     protected init(): void {
         if (this.name !== rootLoggerName) {
@@ -384,6 +386,13 @@ export class Logger implements ILogger {
     }
 
     child(name: string): ILogger {
-        return this.factory(name);
+        const existing = this.cache.get(name);
+        if (existing) {
+            return existing;
+        } else {
+            const child = this.factory(name);
+            this.cache.set(name, child);
+            return child;
+        }
     }
 }

package/src/common/menu/composite-menu-node.ts

@@ -54,11 +54,13 @@ export class CompositeMenuNode implements MutableCompoundMenuNode {
         };
     }
 
-    removeNode(id: string): void {
+    removeNode(id: string): boolean {
         const idx = this._children.findIndex(n => n.id === id);
         if (idx >= 0) {
             this._children.splice(idx, 1);
+            return true;
         }
+        return false;
     }
 
     updateOptions(options?: SubMenuOptions): void {
@@ -108,7 +110,7 @@ export class CompositeMenuNodeWrapper implements MutableCompoundMenuNode {
 
     addNode(node: MenuNode): Disposable { return this.wrapped.addNode(node); }
 
-    removeNode(id: string): void { return this.wrapped.removeNode(id); }
+    removeNode(id: string): boolean { return this.wrapped.removeNode(id); }
 
     updateOptions(options: SubMenuOptions): void { return this.wrapped.updateOptions(options); }
 }

package/src/common/menu/menu-model-registry.ts

@@ -59,6 +59,29 @@ export interface MenuContribution {
     registerMenus(menus: MenuModelRegistry): void;
 }
 
+export enum ChangeKind {
+    ADDED,
+    REMOVED,
+    CHANGED,
+    LINKED
+}
+
+export interface MenuChangedEvent {
+    kind: ChangeKind;
+    path: MenuPath
+}
+
+export interface StructuralMenuChange extends MenuChangedEvent {
+    kind: ChangeKind.ADDED | ChangeKind.REMOVED | ChangeKind.LINKED;
+    affectedChildId: string
+}
+
+export namespace StructuralMenuChange {
+    export function is(evt: MenuChangedEvent): evt is StructuralMenuChange {
+        return evt.kind !== ChangeKind.CHANGED;
+    }
+}
+
 /**
  * The MenuModelRegistry allows to register and unregister menus, submenus and actions
  * via strings and {@link MenuAction}s without the need to access the underlying UI
@@ -69,9 +92,9 @@ export class MenuModelRegistry {
     protected readonly root = new CompositeMenuNode('');
     protected readonly independentSubmenus = new Map<string, MutableCompoundMenuNode>();
 
-    protected readonly onDidChangeEmitter = new Emitter<void>();
+    protected readonly onDidChangeEmitter = new Emitter<MenuChangedEvent>();
 
-    get onDidChange(): Event<void> {
+    get onDidChange(): Event<MenuChangedEvent> {
         return this.onDidChangeEmitter.event;
     }
 
@@ -108,8 +131,21 @@ export class MenuModelRegistry {
     registerMenuNode(menuPath: MenuPath | string, menuNode: MenuNode, group?: string): Disposable {
         const parent = this.getMenuNode(menuPath, group);
         const disposable = parent.addNode(menuNode);
-        this.fireChangeEvent();
-        return this.changeEventOnDispose(disposable);
+        const parentPath = this.getParentPath(menuPath, group);
+        this.fireChangeEvent({
+            kind: ChangeKind.ADDED,
+            path: parentPath,
+            affectedChildId: menuNode.id
+        });
+        return this.changeEventOnDispose(parentPath, menuNode.id, disposable);
+    }
+
+    protected getParentPath(menuPath: MenuPath | string, group?: string): string[] {
+        if (typeof menuPath === 'string') {
+            return group ? [menuPath, group] : [menuPath];
+        } else {
+            return group ? menuPath.concat(group) : menuPath;
+        }
     }
 
     getMenuNode(menuPath: MenuPath | string, group?: string): MutableCompoundMenuNode {
@@ -152,11 +188,19 @@ export class MenuModelRegistry {
         let disposable = Disposable.NULL;
         if (!groupNode) {
             groupNode = new CompositeMenuNode(menuId, label, options, parent);
-            disposable = this.changeEventOnDispose(parent.addNode(groupNode));
+            disposable = this.changeEventOnDispose(groupPath, menuId, parent.addNode(groupNode));
+            this.fireChangeEvent({
+                kind: ChangeKind.ADDED,
+                path: groupPath,
+                affectedChildId: menuId
+            });
         } else {
+            this.fireChangeEvent({
+                kind: ChangeKind.CHANGED,
+                path: groupPath,
+            });
             groupNode.updateOptions({ ...options, label });
         }
-        this.fireChangeEvent();
         return disposable;
     }
 
@@ -165,12 +209,13 @@ export class MenuModelRegistry {
             console.debug(`Independent submenu with path ${id} registered, but given ID already exists.`);
         }
         this.independentSubmenus.set(id, new CompositeMenuNode(id, label, options));
-        return this.changeEventOnDispose(Disposable.create(() => this.independentSubmenus.delete(id)));
+        return this.changeEventOnDispose([], id, Disposable.create(() => this.independentSubmenus.delete(id)));
     }
 
     linkSubmenu(parentPath: MenuPath | string, childId: string | MenuPath, options?: SubMenuOptions, group?: string): Disposable {
         const child = this.getMenuNode(childId);
         const parent = this.getMenuNode(parentPath, group);
+        const affectedPath = this.getParentPath(parentPath, group);
 
         const isRecursive = (node: MenuNodeMetadata, childNode: MenuNodeMetadata): boolean => {
             if (node.id === childNode.id) {
@@ -190,8 +235,13 @@ export class MenuModelRegistry {
 
         const wrapper = new CompositeMenuNodeWrapper(child, parent, options);
         const disposable = parent.addNode(wrapper);
-        this.fireChangeEvent();
-        return this.changeEventOnDispose(disposable);
+        this.fireChangeEvent({
+            kind: ChangeKind.LINKED,
+            path: affectedPath,
+            affectedChildId: child.id
+
+        });
+        return this.changeEventOnDispose(affectedPath, child.id, disposable);
     }
 
     /**
@@ -223,11 +273,14 @@ export class MenuModelRegistry {
         if (menuPath) {
             const parent = this.findGroup(menuPath);
             parent.removeNode(id);
-            this.fireChangeEvent();
-            return;
+            this.fireChangeEvent({
+                kind: ChangeKind.REMOVED,
+                path: menuPath,
+                affectedChildId: id
+            });
+        } else {
+            this.unregisterMenuNode(id);
         }
-
-        this.unregisterMenuNode(id);
     }
 
     /**
@@ -236,16 +289,24 @@ export class MenuModelRegistry {
      * @param id technical identifier of the `MenuNode`.
      */
     unregisterMenuNode(id: string): void {
+        const parentPath: string[] = [];
         const recurse = (root: MutableCompoundMenuNode) => {
             root.children.forEach(node => {
                 if (CompoundMenuNode.isMutable(node)) {
-                    node.removeNode(id);
+                    if (node.removeNode(id)) {
+                        this.fireChangeEvent({
+                            kind: ChangeKind.REMOVED,
+                            path: parentPath,
+                            affectedChildId: id
+                        });
+                    }
+                    parentPath.push(node.id);
                     recurse(node);
+                    parentPath.pop();
                 }
             });
         };
         recurse(this.root);
-        this.fireChangeEvent();
     }
 
     /**
@@ -339,16 +400,20 @@ export class MenuModelRegistry {
         return true;
     }
 
-    protected changeEventOnDispose(disposable: Disposable): Disposable {
+    protected changeEventOnDispose(path: MenuPath, id: string, disposable: Disposable): Disposable {
         return Disposable.create(() => {
             disposable.dispose();
-            this.fireChangeEvent();
+            this.fireChangeEvent({
+                path,
+                affectedChildId: id,
+                kind: ChangeKind.REMOVED
+            });
         });
     }
 
-    protected fireChangeEvent(): void {
+    protected fireChangeEvent<T extends MenuChangedEvent>(evt: T): void {
         if (this.isReady) {
-            this.onDidChangeEmitter.fire();
+            this.onDidChangeEmitter.fire(evt);
         }
     }
 

package/src/common/menu/menu-types.ts

@@ -139,8 +139,9 @@ export interface MutableCompoundMenuNode extends CompoundMenuNode {
      * Removes the first node with the given id.
      *
      * @param id node id.
+     * @returns true if the id was present
      */
-    removeNode(id: string): void;
+    removeNode(id: string): boolean;
 
     /**
      * Fills any `undefined` fields with the values from the {@link options}.

package/src/common/resource.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, named } from 'inversify';
+import { injectable, inject, named, postConstruct } from 'inversify';
 import { TextDocumentContentChangeEvent } from 'vscode-languageserver-protocol';
 import URI from '../common/uri';
 import { ContributionProvider } from './contribution-provider';
@@ -62,6 +62,8 @@ export interface Resource extends Disposable {
     readonly readOnly?: boolean | MarkdownString;
 
     readonly initiallyDirty?: boolean;
+    /** If false, the application should not attempt to auto-save this resource. */
+    readonly autosaveable?: boolean;
     /**
      * Reads latest content of this resource.
      *
@@ -178,6 +180,11 @@ export namespace ResourceError {
 
 export const ResourceResolver = Symbol('ResourceResolver');
 export interface ResourceResolver {
+    /**
+     * Resolvers will be ordered by descending priority.
+     * Default: 0
+     */
+    priority?: number;
     /**
      * Reject if a resource cannot be provided.
      */
@@ -195,6 +202,11 @@ export class DefaultResourceProvider {
         protected readonly resolversProvider: ContributionProvider<ResourceResolver>
     ) { }
 
+    @postConstruct()
+    init(): void {
+        this.resolversProvider.getContributions().sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+
     /**
      * Reject if a resource cannot be provided.
      */
@@ -213,7 +225,7 @@ export class DefaultResourceProvider {
 }
 
 export class MutableResource implements Resource {
-    private contents: string = '';
+    protected contents: string = '';
 
     constructor(readonly uri: URI) {
     }
@@ -278,7 +290,7 @@ export class InMemoryResources implements ResourceResolver {
         const resourceUri = uri.toString();
         const resource = this.resources.get(resourceUri);
         if (!resource) {
-            throw new Error(`Cannot update non-existed in-memory resource '${resourceUri}'`);
+            throw new Error(`Cannot update non-existent in-memory resource '${resourceUri}'`);
         }
         resource.saveContents(contents);
         return resource;
@@ -380,7 +392,8 @@ export class UntitledResourceResolver implements ResourceResolver {
 export class UntitledResource implements Resource {
 
     protected readonly onDidChangeContentsEmitter = new Emitter<void>();
-    initiallyDirty: boolean;
+    readonly initiallyDirty: boolean;
+    readonly autosaveable = false;
     get onDidChangeContents(): Event<void> {
         return this.onDidChangeContentsEmitter.event;
     }

package/src/node/console-logger-server.ts

@@ -18,11 +18,14 @@ import { inject, injectable, postConstruct } from 'inversify';
 import { LoggerWatcher } from '../common/logger-watcher';
 import { LogLevelCliContribution } from './logger-cli-contribution';
 import { ILoggerServer, ILoggerClient, ConsoleLogger, rootLoggerName } from '../common/logger-protocol';
+import { format } from 'util';
+import { EOL } from 'os';
+import * as fs from 'fs';
 
 @injectable()
 export class ConsoleLoggerServer implements ILoggerServer {
 
-    protected client: ILoggerClient | undefined = undefined;
+    protected client?: ILoggerClient;
 
     @inject(LoggerWatcher)
     protected watcher: LoggerWatcher;
@@ -30,6 +33,8 @@ export class ConsoleLoggerServer implements ILoggerServer {
     @inject(LogLevelCliContribution)
     protected cli: LogLevelCliContribution;
 
+    protected logFileStream?: fs.WriteStream;
+
     @postConstruct()
     protected init(): void {
         this.setLogLevel(rootLoggerName, this.cli.defaultLogLevel);
@@ -59,7 +64,22 @@ export class ConsoleLoggerServer implements ILoggerServer {
     async log(name: string, logLevel: number, message: string, params: any[]): Promise<void> {
         const configuredLogLevel = await this.getLogLevel(name);
         if (logLevel >= configuredLogLevel) {
-            ConsoleLogger.log(name, logLevel, message, params);
+            const fullMessage = ConsoleLogger.log(name, logLevel, message, params);
+            this.logToFile(fullMessage, params);
+        }
+    }
+
+    protected logToFile(message: string, params: any[]): void {
+        if (this.cli.logFile && !this.logFileStream) {
+            this.logFileStream = fs.createWriteStream(this.cli.logFile, { flags: 'a' });
+            // Only log errors once to avoid spamming the console
+            this.logFileStream.once('error', error => {
+                console.error(`Error writing to log file ${this.cli.logFile}`, error);
+            });
+        }
+        if (this.logFileStream) {
+            const formatted = format(message, ...params) + EOL;
+            this.logFileStream.write(formatted);
         }
     }
 

package/src/node/logger-backend-module.ts

@@ -16,20 +16,19 @@
 
 import { ContainerModule, Container, interfaces } from 'inversify';
 import { ConnectionHandler, RpcConnectionHandler } from '../common/messaging';
-import { ILogger, LoggerFactory, Logger, setRootLogger, LoggerName, rootLoggerName } from '../common/logger';
+import { ILogger, LoggerFactory, Logger, setRootLogger, LoggerName } from '../common/logger';
 import { ILoggerServer, ILoggerClient, loggerPath, DispatchingLoggerClient } from '../common/logger-protocol';
 import { ConsoleLoggerServer } from './console-logger-server';
 import { LoggerWatcher } from '../common/logger-watcher';
 import { BackendApplicationContribution } from './backend-application';
 import { CliContribution } from './cli';
 import { LogLevelCliContribution } from './logger-cli-contribution';
+import { bindCommonLogger } from '../common/logger-binding';
 
 export function bindLogger(bind: interfaces.Bind, props?: {
     onLoggerServerActivation?: (context: interfaces.Context, server: ILoggerServer) => void
 }): void {
-    bind(LoggerName).toConstantValue(rootLoggerName);
-    bind(ILogger).to(Logger).inSingletonScope().whenTargetIsDefault();
-    bind(LoggerWatcher).toSelf().inSingletonScope();
+    bindCommonLogger(bind);
     bind<ILoggerServer>(ILoggerServer).to(ConsoleLoggerServer).inSingletonScope().onActivation((context, server) => {
         if (props && props.onLoggerServerActivation) {
             props.onLoggerServerActivation(context, server);

package/src/node/logger-cli-contribution.ts

@@ -43,6 +43,8 @@ export class LogLevelCliContribution implements CliContribution {
      */
     protected _defaultLogLevel: LogLevel = LogLevel.INFO;
 
+    protected _logFile?: string;
+
     protected logConfigChangedEvent: Emitter<void> = new Emitter<void>();
 
     get defaultLogLevel(): LogLevel {
@@ -53,6 +55,10 @@ export class LogLevelCliContribution implements CliContribution {
         return this._logLevels;
     }
 
+    get logFile(): string | undefined {
+        return this._logFile;
+    }
+
     configure(conf: yargs.Argv): void {
         conf.option('log-level', {
             description: 'Sets the default log level',
@@ -65,6 +71,12 @@ export class LogLevelCliContribution implements CliContribution {
             type: 'string',
             nargs: 1,
         });
+
+        conf.option('log-file', {
+            description: 'Path to the log file',
+            type: 'string',
+            nargs: 1
+        });
     }
 
     async setArguments(args: yargs.Arguments): Promise<void> {
@@ -87,22 +99,46 @@ export class LogLevelCliContribution implements CliContribution {
                 console.error(`Error reading log config file ${filename}: ${e}`);
             }
         }
+
+        if (args['log-file'] !== undefined) {
+            let filename = args['log-file'] as string;
+            try {
+                filename = path.resolve(filename);
+                try {
+                    const stat = await fs.stat(filename);
+                    if (stat && stat.isFile()) {
+                        // Rename the previous log file to avoid overwriting it
+                        const oldFilename = `${filename}.${stat.ctime.toISOString().replace(/:/g, '-')}.old`;
+                        await fs.rename(filename, oldFilename);
+                    }
+                } catch {
+                    // File does not exist, just continue to create it
+                }
+                await fs.writeFile(filename, '');
+                this._logFile = filename;
+            } catch (e) {
+                console.error(`Error creating log file ${filename}: ${e}`);
+            }
+        }
     }
 
     protected async watchLogConfigFile(filename: string): Promise<void> {
-        await subscribe(filename, async (err, events) => {
+        const dir = path.dirname(filename);
+        await subscribe(dir, async (err, events) => {
             if (err) {
                 console.log(`Error during log file watching ${filename}: ${err}`);
                 return;
             }
             try {
                 for (const event of events) {
-                    switch (event.type) {
-                        case 'create':
-                        case 'update':
-                            await this.slurpLogConfigFile(filename);
-                            this.logConfigChangedEvent.fire(undefined);
-                            break;
+                    if (event.path === filename) {
+                        switch (event.type) {
+                            case 'create':
+                            case 'update':
+                                await this.slurpLogConfigFile(filename);
+                                this.logConfigChangedEvent.fire(undefined);
+                                break;
+                        }
                     }
                 }
             } catch (e) {