@eclipse-glsp/server 1.1.0-next.3d7585d.42

package/src/common/utils/layout-util.ts

@@ -0,0 +1,164 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 EclipseSource 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { GAlignable, GBoundsAware, GEdge, GGraph, GModelElement, GModelRoot, isGAlignable, isGBoundsAware } from '@eclipse-glsp/graph';
+import { ElementAndAlignment, ElementAndBounds, ElementAndRoutingPoints, Point } from '@eclipse-glsp/protocol';
+import { GModelIndex } from '../features/model/gmodel-index';
+import { ArgsUtil } from './args-util';
+import { getOrThrow, GLSPServerError } from './glsp-server-error';
+
+/**
+ * Applies the new bounds to the model.
+ *
+ * @param bounds The new bounds.
+ * @param index  The model index.
+ * @returns The changed element.
+ */
+export function applyBounds(bounds: ElementAndBounds, index: GModelIndex): GBoundsAware | undefined {
+    const element = getOrThrow(index.get(bounds.elementId), 'Model element not found! ID: ' + bounds.elementId);
+    if (isGBoundsAware(element)) {
+        if (bounds.newPosition !== undefined) {
+            element.position = bounds.newPosition;
+        }
+        element.size = bounds.newSize;
+        return element;
+    }
+    return undefined;
+}
+
+/**
+ * Applies the new alignment to the model.
+ *
+ * @param alignment The new alignment.
+ * @param index     The model index.
+ * @returns The changed element.
+ */
+export function applyAlignment(alignment: ElementAndAlignment, index: GModelIndex): GAlignable | undefined {
+    const element = getOrThrow(index.get(alignment.elementId), 'Model element not found! ID: ' + alignment.elementId);
+    if (isGAlignable(element)) {
+        element.alignment = alignment.newAlignment;
+        return element;
+    }
+    return undefined;
+}
+
+/**
+ * Applies the new route to the model.
+ *
+ * @param route The new route.
+ * @param index The model index.
+ * @returns The changed element.
+ */
+export function applyRoute(route: ElementAndRoutingPoints, index: GModelIndex): GEdge {
+    const routingPoints = route.newRoutingPoints ?? [];
+    if (routingPoints.length < 2) {
+        throw new GLSPServerError('Invalid Route!');
+    }
+    // first and last point mark the source and target point
+    const edge = applyRoutingPoints(route, index);
+    const edgeRoutingPoints = edge.routingPoints;
+
+    const args = edge.args ?? {};
+    const source = edgeRoutingPoints.shift()!;
+    const target = edgeRoutingPoints.pop()!;
+    args[ArgsUtil.KEY_EDGE_SOURCE_POINT_X] = source.x;
+    args[ArgsUtil.KEY_EDGE_SOURCE_POINT_Y] = source.y;
+    args[ArgsUtil.KEY_EDGE_TARGET_POINT_X] = target.x;
+    args[ArgsUtil.KEY_EDGE_TARGET_POINT_Y] = target.y;
+    return edge;
+}
+
+/**
+ * Returns the complete route of the given edge. The route, as opposed to the routing points, also contain the source
+ * and target point.
+ *
+ * @param edge The edge from which we get the route
+ * @returns complete edge route
+ */
+export function getRoute(edge: GEdge): ElementAndRoutingPoints {
+    const sourcePoint = ArgsUtil.getEdgeSourcePoint(edge.args);
+    if (!sourcePoint) {
+        throw new GLSPServerError('Cannot get route without source point!');
+    }
+    const targetPoint = ArgsUtil.getEdgeTargetPoint(edge.args);
+    if (!targetPoint) {
+        throw new GLSPServerError('Cannot get route without target point!');
+    }
+    const route: Point[] = [];
+    route.push(sourcePoint);
+    route.push(...edge.routingPoints);
+    route.push(targetPoint);
+    return { elementId: edge.id, newRoutingPoints: route };
+}
+
+export function applyRoutingPoints(routingPoints: ElementAndRoutingPoints, index: GModelIndex): GEdge {
+    const edge = getOrThrow(index.findByClass(routingPoints.elementId, GEdge), 'Model element not found! ID: ' + routingPoints.elementId);
+    edge.routingPoints = routingPoints.newRoutingPoints ?? [];
+    return edge;
+}
+/**
+ * Returns the relative location of the given absolute location within the container.
+ *
+ * @param absoluteLocation absolute location
+ * @param container        container
+ * @return relative location if it can be determined, absolute location in case of error and null if the container
+ *         cannot contain any location.
+ */
+export function getRelativeLocation(absoluteLocation: Point, container: GModelElement): Point | undefined {
+    const allowNegativeCoordinates = container instanceof GGraph;
+    if (isGBoundsAware(container)) {
+        const relativePosition = absoluteToRelative(absoluteLocation, container);
+        const relativeLocation = allowNegativeCoordinates
+            ? relativePosition
+            : { x: Math.max(0, relativePosition.x), y: Math.max(0, relativePosition.y) };
+        return relativeLocation;
+    }
+    return undefined;
+}
+
+/**
+ * Convert a point in absolute coordinates to a point relative to the specified GBoundsAware.
+ * Note: this method only works if the specified {@link GBoundsAware} is part of a
+ * hierarchy of {@link GBoundsAware}. If any of its parents (recursively) does not implement
+ * {@link GBoundsAware}, this method will throw an exception.
+ *
+ * @param absolutePoint
+ * @param modelElement
+ * @returns
+ *         A new point, relative to the coordinates space of the specified {@link GBoundsAware}
+ * @throws Error if the modelElement is not part of a {@link GBoundsAware} hierarchy
+ */
+export function absoluteToRelative(absolutePoint: Point, modelElement: GModelElement & GBoundsAware): Point {
+    let parentElement;
+    if (!(modelElement instanceof GModelRoot)) {
+        parentElement = modelElement.parent;
+    }
+
+    let relativeToParent: Point;
+    if (!parentElement) {
+        relativeToParent = { x: absolutePoint.x, y: absolutePoint.y };
+    } else {
+        if (!isGBoundsAware(parentElement)) {
+            throw new Error(`The element is not part of a GBoundsAware hierarchy: ${modelElement}`);
+        }
+        relativeToParent = absoluteToRelative(absolutePoint, parentElement);
+    }
+
+    const x = modelElement.position?.x ?? 0;
+    const y = modelElement.position?.y ?? 0;
+
+    return { x: relativeToParent.x - x, y: relativeToParent.y - y };
+}

package/src/common/utils/logger.ts

@@ -0,0 +1,72 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { injectable } from 'inversify';
+
+@injectable()
+export abstract class Logger {
+    abstract logLevel: LogLevel;
+
+    abstract caller?: string;
+
+    abstract info(message: string, ...params: any[]): void;
+
+    abstract warn(message: string, ...params: any[]): void;
+
+    abstract error(message: string, ...params: any[]): void;
+
+    abstract debug(message: string, ...params: any[]): void;
+}
+
+export class NullLogger extends Logger {
+    logLevel: LogLevel;
+    caller?: string | undefined;
+    info(message: string, ...params: any[]): void {
+        // no-op
+    }
+    warn(message: string, ...params: any[]): void {
+        // no-op
+    }
+    error(message: string, ...params: any[]): void {
+        // no-op
+    }
+    debug(message: string, ...params: any[]): void {
+        // no-op
+    }
+}
+
+export const LoggerFactory = Symbol('LoggerFactory');
+
+export type LoggerFactory = (caller: string) => Logger;
+
+export enum LogLevel {
+    none = 0,
+    error = 1,
+    warn = 2,
+    info = 3,
+    debug = 4
+}
+
+export function asLogLevel(level: string | number): LogLevel | undefined {
+    let levelKey = level;
+    if (typeof levelKey === 'string') {
+        levelKey = levelKey.toLowerCase();
+    }
+
+    if (levelKey in LogLevel) {
+        return (LogLevel as any)[level];
+    }
+    return undefined;
+}

package/src/common/utils/promise-queue.spec.ts

@@ -0,0 +1,138 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { delay } from '../test/mock-util';
+import { PromiseQueue } from './promise-queue';
+import { expect } from 'chai';
+
+// Helper types and functions that are needed for test setup
+
+/**
+ * Helper class to inspect the state of promise during its resolve() execution.
+ */
+class PromiseState {
+    private _started = false;
+    private _stopped = false;
+    onStartRunnable?: () => void;
+    onStopRunnable?: () => void;
+
+    start(): void {
+        this._started = true;
+        if (this.onStartRunnable) {
+            this.onStartRunnable();
+        }
+    }
+
+    stop(): void {
+        this._stopped = true;
+        if (this.onStopRunnable) {
+            this.onStopRunnable();
+        }
+    }
+
+    onStart(runnable: () => void): void {
+        this.onStartRunnable = runnable;
+    }
+
+    onStop(runnable: () => void): void {
+        this.onStopRunnable = runnable;
+    }
+
+    get started(): boolean {
+        return this._started;
+    }
+
+    get stopped(): boolean {
+        return this._stopped;
+    }
+}
+
+interface TestPromise {
+    state: PromiseState;
+    promise: () => Promise<void>;
+}
+
+function newTestPromise(resolveTime: number): TestPromise {
+    const state = new PromiseState();
+    const promise = async (): Promise<void> => {
+        state.start();
+        await delay(resolveTime);
+        state.stop();
+    };
+    return { state, promise };
+}
+
+let queue = new PromiseQueue();
+
+// Test execution
+describe('test PromiseQueue', () => {
+    beforeEach(() => {
+        queue = new PromiseQueue();
+    });
+    it('enqueue - one element', async () => {
+        const { state, promise } = newTestPromise(100);
+        state.onStart(() => {
+            expect(queue.isBusy).true;
+        });
+        const queEnd = queue.enqueue(promise);
+        expect(queue.isEmpty).true;
+        await queEnd;
+    });
+
+    it('enqueue - two elements', async () => {
+        const p1 = newTestPromise(100);
+        p1.state.onStop(() => expect(p2.state.started).false);
+
+        const p2 = newTestPromise(100);
+
+        p2.state.onStart(() => {
+            expect(queue.isEmpty).true;
+            expect(p1.state.stopped).true;
+        });
+
+        queue.enqueue(p1.promise);
+        const queEnd = queue.enqueue(p2.promise);
+        expect(queue.size).to.be.equal(1);
+        await queEnd;
+    });
+
+    it('enqueue - three elements (first promise in queue has longest resolve time)', async () => {
+        const p1 = newTestPromise(300);
+        p1.state.onStop(() => {
+            expect(p2.state.started).false;
+            expect(p3.state.started).false;
+        });
+
+        const p2 = newTestPromise(200);
+        p2.state.onStart(() => {
+            expect(queue.size).to.be.equal(1);
+            expect(p1.state.stopped).true;
+            expect(p3.state.started).false;
+        });
+
+        const p3 = newTestPromise(100);
+        p3.state.onStart(() => {
+            expect(queue.isEmpty).true;
+            expect(p2.state.stopped).true;
+        });
+
+        queue.enqueue(p1.promise);
+        queue.enqueue(p2.promise);
+        expect(queue.size).to.be.equal(1);
+        const queueEnd = queue.enqueue(p3.promise);
+        expect(queue.size).to.be.equal(2);
+        await queueEnd;
+    });
+});

package/src/common/utils/promise-queue.ts

@@ -0,0 +1,103 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+/**
+ * Description for promises that are put into a queue and
+ * resolved once dequeued.
+ */
+export interface PromiseQueueElement<T = void> {
+    promise: () => Promise<T>;
+    resolve: (value: T) => void;
+    reject: (reason?: any) => void;
+}
+
+/**
+ * A data structure that enables controlled,sequential resolving
+ * of promises. Promises that are put in this queue are processed one by one.
+ * i.e. After the first promise in the queue is resolved, it will be removed from the queue and the resolving of the
+ * the next promise (if present) will start. The queue can only resolve one promise at a given time.
+ */
+export class PromiseQueue<T = void> {
+    protected queue: PromiseQueueElement<T>[] = [];
+    protected busy = false;
+
+    /**
+     * Add a {@link PromiseQueueElement} to the queue
+     * @param promise The element that should be queued
+     * @param atStart if `true` the element is added to the start of queue, otherwise it's added at queue end.
+     * @returns A promise of the queued promise that resolves once dequeued.
+     */
+    enqueue(promise: () => Promise<T>): Promise<T> {
+        return new Promise((resolve, reject) => {
+            const element = {
+                promise,
+                resolve,
+                reject
+            };
+            this.queue.push(element);
+            this.dequeue();
+        });
+    }
+
+    protected dequeue(): boolean {
+        if (this.busy) {
+            return false;
+        }
+
+        const element = this.queue.shift();
+        if (!element) {
+            return false;
+        }
+
+        try {
+            this.busy = true;
+            this.resolveQueuedPromise(element);
+        } catch (error) {
+            element.reject(error);
+            this.busy = false;
+            this.dequeue();
+        }
+        return true;
+    }
+
+    protected async resolveQueuedPromise(element: PromiseQueueElement<T>): Promise<void> {
+        try {
+            const value = await element.promise();
+            return element.resolve(value);
+        } catch (error) {
+            element.reject(error);
+        } finally {
+            this.busy = false;
+            this.dequeue();
+        }
+    }
+
+    get isBusy(): boolean {
+        return this.busy;
+    }
+
+    get size(): number {
+        return this.queue.length;
+    }
+
+    get isEmpty(): boolean {
+        return this.queue.length === 0;
+    }
+
+    clear(): void {
+        this.queue = [];
+    }
+}

package/src/common/utils/registry.spec.ts

@@ -0,0 +1,223 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { MultiRegistry, Registry } from './registry';
+import { expect } from 'chai';
+
+describe('Test Registry', () => {
+    let registry: Registry<string, string>;
+
+    beforeEach(() => {
+        registry = new Registry();
+    });
+
+    it('register - with new key-value pair', () => {
+        const key = 'key';
+        const value = 'value';
+        expect(registry.register(key, value)).true;
+        expect(registry.get(key), value);
+    });
+
+    it('register -  with key-value pair with a already registered key', () => {
+        // Setup
+        const key = 'key';
+        const value = 'value';
+        expect(registry.register(key, value)).true;
+        // Test execution
+        expect(registry.register(key, 'newValue')).false;
+        expect(registry.get(key), value);
+    });
+
+    it('deregister - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const value = 'value';
+        expect(registry.register(key, value)).true;
+        // Test execution
+        expect(registry.deregister(key)).true;
+        expect(registry.get(key), undefined);
+    });
+
+    it('deregister - with unregistered key', () => {
+        expect(registry.deregister('unregisteredKey')).false;
+    });
+
+    it('haskey - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const value = 'value';
+        expect(registry.register(key, value)).true;
+        // Test execution
+        expect(registry.hasKey(key)).true;
+    });
+
+    it('haskey - with unregistered key', () => {
+        expect(registry.deregister('unregisteredKey')).false;
+    });
+
+    it('get - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const value = 'value';
+        expect(registry.register(key, value)).true;
+        // Test execution
+        expect(registry.get(key), value);
+    });
+
+    it('get - with unregistered key', () => {
+        expect(registry.get('unregisteredKey'), undefined);
+    });
+
+    it('getAll - should return three values', () => {
+        // Setup
+        const e1 = { key: 'key1', value: 'value1' };
+        const e2 = { key: 'key2', value: 'value2' };
+        const e3 = { key: 'key3', value: 'value3' };
+        registry.register(e1.key, e1.value);
+        registry.register(e2.key, e2.value);
+        registry.register(e3.key, e3.value);
+        // Test execution
+        const result = registry.getAll();
+        expect(result).to.have.length(3);
+        expect(result.includes(e1.value)).true;
+        expect(result.includes(e2.value)).true;
+        expect(result.includes(e3.value)).true;
+    });
+
+    it('keys - should return three keys', () => {
+        // Setup
+        const e1 = { key: 'key1', value: 'value1' };
+        const e2 = { key: 'key2', value: 'value2' };
+        const e3 = { key: 'key3', value: 'value3' };
+        registry.register(e1.key, e1.value);
+        registry.register(e2.key, e2.value);
+        registry.register(e3.key, e3.value);
+        // Test execution
+        const result = registry.keys();
+        expect(result).to.have.length(3);
+        expect(result.includes(e1.key)).true;
+        expect(result.includes(e2.key)).true;
+        expect(result.includes(e3.key)).true;
+    });
+});
+
+describe('Test MapMultiRegistry', () => {
+    let multiRegistry: MultiRegistry<string, string>;
+
+    beforeEach(() => {
+        multiRegistry = new MultiRegistry();
+    });
+
+    it('register - with new key-value pair', () => {
+        // Setup
+        const e1 = { key: 'key', value: 'value' };
+        const e2 = { key: e1.key, value: 'value2' };
+
+        multiRegistry.register(e1.key, e1.value);
+        multiRegistry.register(e2.key, e2.value);
+
+        const resultValue = multiRegistry.get(e1.key);
+        expect(resultValue).to.not.be.undefined;
+        expect(resultValue!.length).to.be.equal(2);
+        expect(resultValue!.includes(e1.value)).true;
+        expect(resultValue!.includes(e2.value)).true;
+    });
+
+    it('deregister - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const existingValue = ['value', 'value2'];
+        multiRegistry.register(key, existingValue[0]);
+        multiRegistry.register(key, existingValue[1]);
+        // Test execution
+        expect(multiRegistry.deregister(key, existingValue[1])).true;
+        const result = multiRegistry.get(key);
+        expect(result.length).to.be.equal(1);
+        expect(result[0], existingValue[0]);
+    });
+
+    it('deregister - with unregistered key', () => {
+        expect(multiRegistry.deregister('unregisteredKey', 'someValue')).false;
+    });
+
+    it('deregisterAll - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const existingValue = ['value', 'value2'];
+        multiRegistry.register(key, existingValue[0]);
+        multiRegistry.register(key, existingValue[1]);
+        expect(multiRegistry.deregisterAll(key)).true;
+        expect(multiRegistry.get(key)).to.have.length(0);
+    });
+
+    it('deregisterAll - with unregistered key', () => {
+        expect(multiRegistry.deregisterAll('unregisteredKey')).false;
+    });
+
+    it('haskey - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const existingValue = 'value';
+        multiRegistry.register(key, existingValue);
+        // Test execution
+        expect(multiRegistry.hasKey(key)).true;
+    });
+
+    it('haskey - with unregistered key', () => {
+        expect(multiRegistry.hasKey('unregisteredKey')).false;
+    });
+
+    it('get - with registered key', () => {
+        // Setup
+        const key = 'key';
+        const existingValue = 'value';
+        multiRegistry.register(key, existingValue);
+        // Test execution
+        expect(multiRegistry.get(key).length).to.be.equal(1);
+        expect(multiRegistry.get(key).includes(existingValue)).true;
+    });
+
+    it('get - with unregistered key', () => {
+        expect(multiRegistry.get('unregisteredKey')).to.have.length(0);
+    });
+
+    it('getAll', () => {
+        // Setup
+        const e1 = { key: 'key1', value: ['value1', 'value2'] };
+        const e2 = { key: 'key2', value: ['value3'] };
+        multiRegistry.register(e1.key, e1.value[0]);
+        multiRegistry.register(e1.key, e1.value[1]);
+        multiRegistry.register(e2.key, e2.value[0]);
+        // Test execution
+        const result = multiRegistry.getAll();
+        expect(result).to.have.length(3);
+        expect(e1.value.every(v => result.includes(v))).true;
+        expect(e2.value.every(v => result.includes(v))).true;
+    });
+
+    it('keys', () => {
+        // Setup
+        const e1 = { key: 'key1', value: ['value1', 'value2'] };
+        const e2 = { key: 'key2', value: ['value3'] };
+        multiRegistry.register(e1.key, e1.value[0]);
+        multiRegistry.register(e1.key, e1.value[1]);
+        multiRegistry.register(e2.key, e2.value[0]);
+        // Test execution
+        const result = multiRegistry.keys();
+        expect(result.length).to.be.equal(2);
+        expect(result.includes(e1.key)).true;
+        expect(result.includes(e2.key)).true;
+    });
+});