@theia/variable-resolver 1.53.0-next.55 → 1.53.0-next.64

package/src/browser/variable-resolver-service.ts

@@ -1,185 +1,185 @@
-// *****************************************************************************
-// Copyright (C) 2018 Red Hat, Inc. 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
-// *****************************************************************************
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { injectable, inject } from '@theia/core/shared/inversify';
-import { VariableRegistry } from './variable';
-import URI from '@theia/core/lib/common/uri';
-import { CommandIdVariables } from '../common/variable-types';
-import { isCancelled } from '@theia/core';
-
-export interface VariableResolveOptions {
-    context?: URI;
-    /**
-     * Used for resolving inputs, see https://code.visualstudio.com/docs/editor/variables-reference#_input-variables
-     */
-    configurationSection?: string;
-    commandIdVariables?: CommandIdVariables;
-    configuration?: unknown;
-}
-
-/**
- * The variable resolver service should be used to resolve variables in strings.
- */
-@injectable()
-export class VariableResolverService {
-
-    protected static VAR_REGEXP = /\$\{(.*?)\}/g;
-
-    @inject(VariableRegistry) protected readonly variableRegistry: VariableRegistry;
-
-    /**
-     * Resolve the variables in the given string array.
-     * @param value The array of data to resolve variables in.
-     * @param options Options of the variable resolution.
-     * @returns Promise to array with variables resolved. Never rejects.
-     *
-     * @deprecated since 1.28.0 use {@link resolve} instead.
-     */
-    resolveArray(value: string[], options: VariableResolveOptions = {}): Promise<string[] | undefined> {
-        return this.resolve(value, options);
-    }
-
-    /**
-     * Resolve the variables for all strings found in the object and nested objects.
-     * @param value Data to resolve variables in.
-     * @param options Options of the variable resolution
-     * @returns Promise to object with variables resolved. Returns `undefined` if a variable resolution was cancelled.
-     */
-    async resolve<T>(value: T, options: VariableResolveOptions = {}): Promise<T | undefined> {
-        const context = new VariableResolverService.Context(this.variableRegistry, options);
-        try {
-            return await this.doResolve(value, context);
-        } catch (error) {
-            if (isCancelled(error)) {
-                return undefined;
-            }
-            throw error;
-        }
-    }
-
-    protected async doResolve(value: any, context: VariableResolverService.Context): Promise<any> {
-        // eslint-disable-next-line no-null/no-null
-        if (value === undefined || value === null) {
-            return value;
-        }
-        if (typeof value === 'string') {
-            return this.doResolveString(value, context);
-        }
-        if (Array.isArray(value)) {
-            return this.doResolveArray(value, context);
-        }
-        if (typeof value === 'object') {
-            return this.doResolveObject(value, context);
-        }
-        return value;
-    }
-
-    protected async doResolveObject(obj: object, context: VariableResolverService.Context): Promise<object> {
-        const result: {
-            [prop: string]: Object | undefined
-        } = {};
-        for (const name of Object.keys(obj)) {
-            const value = (obj as any)[name];
-            const resolved = await this.doResolve(value, context);
-            result[name] = resolved;
-        }
-        return result;
-    }
-
-    protected async doResolveArray(values: Array<Object | undefined>, context: VariableResolverService.Context): Promise<Array<Object | undefined>> {
-        const result: (Object | undefined)[] = [];
-        for (const value of values) {
-            const resolved = await this.doResolve(value, context);
-            result.push(resolved);
-        }
-        return result;
-    }
-
-    protected async doResolveString(value: string, context: VariableResolverService.Context): Promise<string> {
-        await this.resolveVariables(value, context);
-        return value.replace(VariableResolverService.VAR_REGEXP, (match: string, varName: string) => {
-            const varValue = context.get(varName);
-            return varValue !== undefined ? varValue : match;
-        });
-    }
-
-    protected async resolveVariables(value: string, context: VariableResolverService.Context): Promise<void> {
-        const variableRegExp = new RegExp(VariableResolverService.VAR_REGEXP);
-        let match;
-        // eslint-disable-next-line no-null/no-null
-        while ((match = variableRegExp.exec(value)) !== null) {
-            const variableName = match[1];
-            await context.resolve(variableName);
-        }
-    }
-}
-export namespace VariableResolverService {
-
-    export class Context {
-
-        protected readonly resolved = new Map<string, string | undefined>();
-
-        constructor(
-            protected readonly variableRegistry: VariableRegistry,
-            protected readonly options: VariableResolveOptions
-        ) { }
-
-        get(name: string): string | undefined {
-            return this.resolved.get(name);
-        }
-
-        async resolve(name: string): Promise<void> {
-            if (this.resolved.has(name)) {
-                return;
-            }
-            try {
-                let variableName = name;
-                let argument: string | undefined;
-                const parts = name.split(':', 2);
-                if (parts.length > 1) {
-                    variableName = parts[0];
-                    argument = parts[1];
-                }
-                const variable = this.variableRegistry.getVariable(variableName);
-                const resolved = await variable?.resolve(
-                    this.options.context,
-                    argument,
-                    this.options.configurationSection,
-                    this.options.commandIdVariables,
-                    this.options.configuration
-                );
-                if (
-                    typeof resolved === 'bigint' ||
-                    typeof resolved === 'boolean' ||
-                    typeof resolved === 'number' ||
-                    typeof resolved === 'string'
-                ) {
-                    this.resolved.set(name, `${resolved}`);
-                } else {
-                    this.resolved.set(name, undefined);
-                }
-            } catch (e) {
-                if (isCancelled(e)) {
-                    throw e;
-                }
-                this.resolved.set(name, undefined);
-                console.error(`Failed to resolve '${name}' variable:`, e);
-            }
-        }
-    }
-}
+// *****************************************************************************
+// Copyright (C) 2018 Red Hat, Inc. 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
+// *****************************************************************************
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { injectable, inject } from '@theia/core/shared/inversify';
+import { VariableRegistry } from './variable';
+import URI from '@theia/core/lib/common/uri';
+import { CommandIdVariables } from '../common/variable-types';
+import { isCancelled } from '@theia/core';
+
+export interface VariableResolveOptions {
+    context?: URI;
+    /**
+     * Used for resolving inputs, see https://code.visualstudio.com/docs/editor/variables-reference#_input-variables
+     */
+    configurationSection?: string;
+    commandIdVariables?: CommandIdVariables;
+    configuration?: unknown;
+}
+
+/**
+ * The variable resolver service should be used to resolve variables in strings.
+ */
+@injectable()
+export class VariableResolverService {
+
+    protected static VAR_REGEXP = /\$\{(.*?)\}/g;
+
+    @inject(VariableRegistry) protected readonly variableRegistry: VariableRegistry;
+
+    /**
+     * Resolve the variables in the given string array.
+     * @param value The array of data to resolve variables in.
+     * @param options Options of the variable resolution.
+     * @returns Promise to array with variables resolved. Never rejects.
+     *
+     * @deprecated since 1.28.0 use {@link resolve} instead.
+     */
+    resolveArray(value: string[], options: VariableResolveOptions = {}): Promise<string[] | undefined> {
+        return this.resolve(value, options);
+    }
+
+    /**
+     * Resolve the variables for all strings found in the object and nested objects.
+     * @param value Data to resolve variables in.
+     * @param options Options of the variable resolution
+     * @returns Promise to object with variables resolved. Returns `undefined` if a variable resolution was cancelled.
+     */
+    async resolve<T>(value: T, options: VariableResolveOptions = {}): Promise<T | undefined> {
+        const context = new VariableResolverService.Context(this.variableRegistry, options);
+        try {
+            return await this.doResolve(value, context);
+        } catch (error) {
+            if (isCancelled(error)) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+
+    protected async doResolve(value: any, context: VariableResolverService.Context): Promise<any> {
+        // eslint-disable-next-line no-null/no-null
+        if (value === undefined || value === null) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            return this.doResolveString(value, context);
+        }
+        if (Array.isArray(value)) {
+            return this.doResolveArray(value, context);
+        }
+        if (typeof value === 'object') {
+            return this.doResolveObject(value, context);
+        }
+        return value;
+    }
+
+    protected async doResolveObject(obj: object, context: VariableResolverService.Context): Promise<object> {
+        const result: {
+            [prop: string]: Object | undefined
+        } = {};
+        for (const name of Object.keys(obj)) {
+            const value = (obj as any)[name];
+            const resolved = await this.doResolve(value, context);
+            result[name] = resolved;
+        }
+        return result;
+    }
+
+    protected async doResolveArray(values: Array<Object | undefined>, context: VariableResolverService.Context): Promise<Array<Object | undefined>> {
+        const result: (Object | undefined)[] = [];
+        for (const value of values) {
+            const resolved = await this.doResolve(value, context);
+            result.push(resolved);
+        }
+        return result;
+    }
+
+    protected async doResolveString(value: string, context: VariableResolverService.Context): Promise<string> {
+        await this.resolveVariables(value, context);
+        return value.replace(VariableResolverService.VAR_REGEXP, (match: string, varName: string) => {
+            const varValue = context.get(varName);
+            return varValue !== undefined ? varValue : match;
+        });
+    }
+
+    protected async resolveVariables(value: string, context: VariableResolverService.Context): Promise<void> {
+        const variableRegExp = new RegExp(VariableResolverService.VAR_REGEXP);
+        let match;
+        // eslint-disable-next-line no-null/no-null
+        while ((match = variableRegExp.exec(value)) !== null) {
+            const variableName = match[1];
+            await context.resolve(variableName);
+        }
+    }
+}
+export namespace VariableResolverService {
+
+    export class Context {
+
+        protected readonly resolved = new Map<string, string | undefined>();
+
+        constructor(
+            protected readonly variableRegistry: VariableRegistry,
+            protected readonly options: VariableResolveOptions
+        ) { }
+
+        get(name: string): string | undefined {
+            return this.resolved.get(name);
+        }
+
+        async resolve(name: string): Promise<void> {
+            if (this.resolved.has(name)) {
+                return;
+            }
+            try {
+                let variableName = name;
+                let argument: string | undefined;
+                const parts = name.split(':', 2);
+                if (parts.length > 1) {
+                    variableName = parts[0];
+                    argument = parts[1];
+                }
+                const variable = this.variableRegistry.getVariable(variableName);
+                const resolved = await variable?.resolve(
+                    this.options.context,
+                    argument,
+                    this.options.configurationSection,
+                    this.options.commandIdVariables,
+                    this.options.configuration
+                );
+                if (
+                    typeof resolved === 'bigint' ||
+                    typeof resolved === 'boolean' ||
+                    typeof resolved === 'number' ||
+                    typeof resolved === 'string'
+                ) {
+                    this.resolved.set(name, `${resolved}`);
+                } else {
+                    this.resolved.set(name, undefined);
+                }
+            } catch (e) {
+                if (isCancelled(e)) {
+                    throw e;
+                }
+                this.resolved.set(name, undefined);
+                console.error(`Failed to resolve '${name}' variable:`, e);
+            }
+        }
+    }
+}

package/src/browser/variable.spec.ts

@@ -1,106 +1,106 @@
-// *****************************************************************************
-// Copyright (C) 2018 Red Hat, Inc. 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 * as chai from 'chai';
-import { Container, ContainerModule } from '@theia/core/shared/inversify';
-import { ILogger, Disposable } from '@theia/core/lib/common';
-import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
-import { Variable, VariableRegistry } from './variable';
-
-const expect = chai.expect;
-let variableRegistry: VariableRegistry;
-
-before(() => {
-    chai.config.showDiff = true;
-    chai.config.includeStack = true;
-});
-
-describe('variable api', () => {
-    let testContainer: Container;
-
-    before(() => {
-        testContainer = new Container();
-        const module = new ContainerModule((bind, unbind, isBound, rebind) => {
-            bind(ILogger).to(MockLogger);
-            bind(VariableRegistry).toSelf();
-        });
-        testContainer.load(module);
-    });
-
-    beforeEach(() => {
-        variableRegistry = testContainer.get<VariableRegistry>(VariableRegistry);
-    });
-
-    it('should register and return variable', () => {
-        registerTestVariable();
-
-        const variable = variableRegistry.getVariable(TEST_VARIABLE.name);
-        expect(variable).is.not.undefined;
-        if (variable) {
-            expect(variable.name).is.equal(TEST_VARIABLE.name);
-        }
-    });
-
-    it('should not register a variable for already existed name', () => {
-        const variables: Variable[] = [
-            {
-                name: 'workspaceRoot',
-                description: 'workspace root URI',
-                resolve: () => Promise.resolve('')
-            },
-            {
-                name: 'workspaceRoot',
-                description: 'workspace root URI 2',
-                resolve: () => Promise.resolve('')
-            }
-        ];
-        variables.forEach(v => variableRegistry.registerVariable(v));
-
-        const registeredVariables = variableRegistry.getVariables();
-        expect(registeredVariables.length).to.be.equal(1);
-        expect(registeredVariables[0].name).to.be.equal('workspaceRoot');
-        expect(registeredVariables[0].description).to.be.equal('workspace root URI');
-    });
-
-    it('should dispose variable', () => {
-        const disposable = registerTestVariable();
-        disposable.dispose();
-
-        const variable = variableRegistry.getVariable(TEST_VARIABLE.name);
-        expect(variable).is.undefined;
-    });
-
-    it('should unregister variables on dispose', () => {
-        registerTestVariable();
-
-        let variables = variableRegistry.getVariables();
-        expect(variables.length).to.be.equal(1);
-
-        variableRegistry.dispose();
-
-        variables = variableRegistry.getVariables();
-        expect(variables.length).to.be.equal(0);
-    });
-});
-
-const TEST_VARIABLE: Variable = {
-    name: 'workspaceRoot',
-    resolve: () => Promise.resolve('')
-};
-
-function registerTestVariable(): Disposable {
-    return variableRegistry.registerVariable(TEST_VARIABLE);
-}
+// *****************************************************************************
+// Copyright (C) 2018 Red Hat, Inc. 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 * as chai from 'chai';
+import { Container, ContainerModule } from '@theia/core/shared/inversify';
+import { ILogger, Disposable } from '@theia/core/lib/common';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { Variable, VariableRegistry } from './variable';
+
+const expect = chai.expect;
+let variableRegistry: VariableRegistry;
+
+before(() => {
+    chai.config.showDiff = true;
+    chai.config.includeStack = true;
+});
+
+describe('variable api', () => {
+    let testContainer: Container;
+
+    before(() => {
+        testContainer = new Container();
+        const module = new ContainerModule((bind, unbind, isBound, rebind) => {
+            bind(ILogger).to(MockLogger);
+            bind(VariableRegistry).toSelf();
+        });
+        testContainer.load(module);
+    });
+
+    beforeEach(() => {
+        variableRegistry = testContainer.get<VariableRegistry>(VariableRegistry);
+    });
+
+    it('should register and return variable', () => {
+        registerTestVariable();
+
+        const variable = variableRegistry.getVariable(TEST_VARIABLE.name);
+        expect(variable).is.not.undefined;
+        if (variable) {
+            expect(variable.name).is.equal(TEST_VARIABLE.name);
+        }
+    });
+
+    it('should not register a variable for already existed name', () => {
+        const variables: Variable[] = [
+            {
+                name: 'workspaceRoot',
+                description: 'workspace root URI',
+                resolve: () => Promise.resolve('')
+            },
+            {
+                name: 'workspaceRoot',
+                description: 'workspace root URI 2',
+                resolve: () => Promise.resolve('')
+            }
+        ];
+        variables.forEach(v => variableRegistry.registerVariable(v));
+
+        const registeredVariables = variableRegistry.getVariables();
+        expect(registeredVariables.length).to.be.equal(1);
+        expect(registeredVariables[0].name).to.be.equal('workspaceRoot');
+        expect(registeredVariables[0].description).to.be.equal('workspace root URI');
+    });
+
+    it('should dispose variable', () => {
+        const disposable = registerTestVariable();
+        disposable.dispose();
+
+        const variable = variableRegistry.getVariable(TEST_VARIABLE.name);
+        expect(variable).is.undefined;
+    });
+
+    it('should unregister variables on dispose', () => {
+        registerTestVariable();
+
+        let variables = variableRegistry.getVariables();
+        expect(variables.length).to.be.equal(1);
+
+        variableRegistry.dispose();
+
+        variables = variableRegistry.getVariables();
+        expect(variables.length).to.be.equal(0);
+    });
+});
+
+const TEST_VARIABLE: Variable = {
+    name: 'workspaceRoot',
+    resolve: () => Promise.resolve('')
+};
+
+function registerTestVariable(): Disposable {
+    return variableRegistry.registerVariable(TEST_VARIABLE);
+}