@eclipse-glsp/server 1.1.0-RC05

package/src/common/actions/client-action-handler.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * 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 { Action, ActionMessage } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { ClientActionKinds, ClientId } from '../di/service-identifiers';
+import { GLSPClientProxy } from '../protocol/glsp-client-proxy';
+
+/**
+ * The client action handler is responsible of handling action kinds that are intended for the
+ * GLSP client, by sending them to the client over json-rpc.
+ */
+
+@injectable()
+export class ClientActionHandler implements ClientActionHandler {
+    @inject(GLSPClientProxy)
+    @optional()
+    protected glspClient?: GLSPClientProxy;
+
+    @inject(ClientId)
+    protected readonly clientId: string;
+
+    constructor(@inject(ClientActionKinds) @optional() public actionKinds: string[] = []) {}
+
+    execute(action: Action): [] {
+        this.send(action);
+        return [];
+    }
+
+    protected send(action: Action): void {
+        const message: ActionMessage = { action, clientId: this.clientId };
+        if (this.glspClient) {
+            this.glspClient.process(message);
+            return;
+        }
+        throw new Error('Could not send message to client. No GLSPClientProxy is defined');
+    }
+}

package/src/common/actions/global-action-provider.spec.ts

@@ -0,0 +1,79 @@
+/********************************************************************************
+ * 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 { Container, ContainerModule } from 'inversify';
+import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import { ClientSessionInitializer } from '../session/client-session-initializer';
+import * as mock from '../test/mock-util';
+import { Logger } from '../utils/logger';
+import { ActionHandler } from './action-handler';
+import { ActionHandlerRegistry } from './action-handler-registry';
+import { DefaultGlobalActionProvider } from './global-action-provider';
+import * as sinon from 'sinon';
+import { expect } from 'chai';
+
+describe('test DefaultGlobalActionProvider', () => {
+    const container = new Container();
+    const serverActions = ['A1', 'A2', 'A3'];
+    const clientActions = ['C1', 'C2'];
+    const diagramType = 'myDiagramType';
+
+    const handler1Actions = ['A1', 'A2'];
+    const handler2Actions = ['A2', 'A3'];
+
+    const h1 = new mock.StubActionHandler(handler1Actions);
+    const h2 = new mock.StubActionHandler(handler2Actions);
+
+    const handlerRegistry = new ActionHandlerRegistry();
+    sinon.stub(handlerRegistry, 'getAll').returns([h1, h2]);
+
+    const diagramModule1 = new ContainerModule(bind => {
+        bind(ClientSessionInitializer).toConstantValue(new mock.StubClientSessionInitializer());
+        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler1Actions));
+        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler2Actions));
+        bind(ActionHandlerRegistry).toConstantValue(handlerRegistry);
+        bind(ClientActionKinds).toConstantValue(clientActions[0]);
+        bind(ClientActionKinds).toConstantValue(clientActions[1]);
+    });
+
+    const diagramModules = new Map<string, ContainerModule[]>();
+    diagramModules.set(diagramType, [diagramModule1]);
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new mock.StubLogger());
+            bind(InjectionContainer).toConstantValue(container);
+            bind(DiagramModules).toConstantValue(diagramModules);
+        })
+    );
+
+    const actionProvider = container.resolve(DefaultGlobalActionProvider);
+
+    it('serverActionsKinds', () => {
+        const result = actionProvider.serverActionKinds;
+        expect(result.size).to.be.equal(1);
+        const resultServerActions = result.get(diagramType);
+        expect(resultServerActions).to.not.be.undefined;
+        expect(serverActions.every(action => resultServerActions!.includes(action))).true;
+    });
+
+    it('clientActionKinds', () => {
+        const result = actionProvider.clientActionKinds;
+        expect(result.size).to.be.equal(1);
+        const resultClientActions = result.get(diagramType);
+        expect(resultClientActions).to.not.be.undefined;
+        expect(clientActions.every(action => resultClientActions!.includes(action))).true;
+    });
+});

package/src/common/actions/global-action-provider.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 { Container, ContainerModule, inject, injectable } from 'inversify';
+import { ClientActionKinds, DiagramModules, InjectionContainer } from '../di/service-identifiers';
+import { ClientSessionInitializer } from '../session/client-session-initializer';
+import { ActionHandlerRegistry } from './action-handler-registry';
+import { ClientActionHandler } from './client-action-handler';
+
+export const GlobalActionProvider = Symbol('GlobalActionProvider');
+
+export interface GlobalActionProvider {
+    readonly serverActionKinds: Map<string, string[]>;
+    readonly clientActionKinds: Map<string, string[]>;
+}
+
+@injectable()
+export class DefaultGlobalActionProvider implements GlobalActionProvider {
+    public readonly serverActionKinds: Map<string, string[]>;
+    public readonly clientActionKinds: Map<string, string[]>;
+
+    constructor(
+        @inject(InjectionContainer) serverContainer: Container,
+        @inject(DiagramModules) diagramModules: Map<string, ContainerModule[]>
+    ) {
+        this.serverActionKinds = new Map();
+        this.clientActionKinds = new Map();
+        diagramModules.forEach((modules, diagramType) => {
+            const container = this.createDiagramContainer(serverContainer, modules);
+            const initializers = container.getAll<ClientSessionInitializer>(ClientSessionInitializer);
+            initializers.forEach(service => service.initialize());
+            this.loadServerActionKinds(diagramType, container);
+            this.loadClientActionKinds(diagramType, container);
+            container.unbindAll();
+        });
+    }
+
+    createDiagramContainer(serverContainer: Container, modules: ContainerModule[]): Container {
+        const container = serverContainer.createChild();
+        container.load(...modules);
+        return container;
+    }
+
+    loadServerActionKinds(diagramType: string, diagramContainer: Container): void {
+        const handlerRegistry = diagramContainer.get<ActionHandlerRegistry>(ActionHandlerRegistry);
+        const diagramServerActions = this.serverActionKinds.get(diagramType) ?? [];
+        handlerRegistry
+            .getAll()
+            .filter(handler => !(handler instanceof ClientActionHandler))
+            .forEach(handler => diagramServerActions.push(...handler.actionKinds));
+        this.serverActionKinds.set(diagramType, [...new Set(diagramServerActions)]);
+    }
+
+    loadClientActionKinds(diagramType: string, diagramContainer: Container): void {
+        const clientActionKinds = diagramContainer.getAll<string>(ClientActionKinds);
+        const diagramClientActions = this.clientActionKinds.get(diagramType) ?? [];
+        diagramClientActions.push(...clientActionKinds);
+        this.clientActionKinds.set(diagramType, diagramClientActions);
+    }
+}

package/src/common/command/command-stack.spec.ts

@@ -0,0 +1,239 @@
+/********************************************************************************
+ * Copyright (c) 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 { expect } from 'chai';
+import { Container, ContainerModule } from 'inversify';
+import * as sinon from 'sinon';
+import { StubCommand, StubLogger } from '../test/mock-util';
+import { Logger } from '../utils/logger';
+import { DefaultCommandStack } from './command-stack';
+
+describe('test DefaultCommandStack', () => {
+    const sandbox = sinon.createSandbox();
+    const container = new Container();
+
+    const command1 = sandbox.stub(new StubCommand());
+    const command2 = sandbox.stub(new StubCommand());
+    let commandStack: DefaultCommandStack;
+
+    container.load(
+        new ContainerModule(bind => {
+            bind(Logger).toConstantValue(new StubLogger());
+        })
+    );
+    commandStack = container.resolve(DefaultCommandStack);
+
+    afterEach(() => {
+        sandbox.reset();
+        commandStack = container.resolve(DefaultCommandStack);
+    });
+
+    describe('execute', () => {
+        it('should execute the given command and become dirty', () => {
+            expect(commandStack.isDirty).to.be.false;
+            commandStack.execute(command1);
+            expect(command1.execute.calledOnce).to.be.true;
+            expect(commandStack.isDirty).to.be.true;
+        });
+
+        it('should execute the given commands in order and become dirty', () => {
+            expect(commandStack.isDirty).to.be.false;
+            commandStack.execute(command1);
+            commandStack.execute(command2);
+
+            expect(command1.execute.calledOnce).to.be.true;
+            expect(command2.execute.calledOnce).to.be.true;
+            expect(command2.execute.calledAfter(command1.execute)).to.be.true;
+            expect(commandStack.isDirty).to.be.true;
+        });
+
+        it('should be able to undo after execute', () => {
+            expect(commandStack.canUndo()).to.be.false;
+            commandStack.execute(command1);
+            expect(commandStack.canUndo()).to.be.true;
+        });
+
+        it('should clear the redo stack after execution', () => {
+            commandStack['commands'].push(command2);
+            commandStack['top'] = -1;
+            expect(commandStack.canRedo()).to.be.true;
+
+            commandStack.execute(command1);
+            expect(commandStack.canRedo()).to.be.false;
+        });
+
+        it('should flush the stack in case of an execution error', () => {
+            command2.execute.throwsException();
+            const flushSpy = sandbox.spy(commandStack, 'flush');
+
+            expect(() => commandStack.execute(command2)).to.throw();
+            expect(command2.execute.calledOnce).to.be.true;
+            expect(flushSpy.calledOnce).to.be.true;
+        });
+    });
+
+    describe('undo', () => {
+        it('should do nothing if the command stack is empty', () => {
+            expect(commandStack.isDirty).to.be.false;
+
+            commandStack.undo();
+            expect(commandStack.canUndo()).to.be.false;
+            expect(commandStack.canRedo()).to.be.false;
+            expect(commandStack.isDirty).to.be.false;
+        });
+
+        it('should undo the command and become non-dirty again', () => {
+            commandStack['commands'].push(command1);
+            commandStack['top'] = 0;
+            expect(commandStack.isDirty).to.be.true;
+            expect(commandStack.canUndo()).to.be.true;
+            expect(commandStack.canRedo()).to.be.false;
+
+            commandStack.undo();
+            expect(command1.undo.calledOnce).to.be.true;
+            expect(commandStack.isDirty).to.be.false;
+            expect(commandStack.canRedo()).to.be.true;
+            expect(commandStack.canUndo()).to.be.false;
+        });
+
+        it('should undo multiple command and become non-dirty again', () => {
+            commandStack['commands'].push(command1, command2);
+            commandStack['top'] = 1;
+            expect(commandStack.isDirty).to.be.true;
+            expect(commandStack.canUndo()).to.be.true;
+            expect(commandStack.canRedo()).to.be.false;
+
+            commandStack.undo();
+            expect(command2.undo.calledOnce).to.be.true;
+            expect(commandStack.canRedo()).to.be.true;
+            expect(commandStack.canUndo()).to.be.true;
+            expect(commandStack.isDirty).to.be.true;
+
+            commandStack.undo();
+            expect(command1.undo.calledOnce).to.be.true;
+            expect(command1.undo.calledAfter(command2.undo)).to.be.true;
+            expect(commandStack.isDirty).to.be.false;
+            expect(commandStack.canRedo()).to.be.true;
+            expect(commandStack.canUndo()).to.be.false;
+        });
+        it('should flush the stack in case of an execution error', () => {
+            command2.undo.throwsException();
+            const flushSpy = sandbox.spy(commandStack, 'flush');
+            commandStack['commands'].push(command2);
+            commandStack['top'] = 0;
+
+            expect(() => commandStack.undo()).to.throw();
+            expect(command2.undo.calledOnce).to.be.true;
+            expect(flushSpy.calledOnce).to.be.true;
+        });
+    });
+
+    describe('redo', () => {
+        it('should do nothing if the command stack is empty', () => {
+            expect(commandStack.isDirty).to.be.false;
+
+            commandStack.redo();
+            expect(commandStack.canUndo()).to.be.false;
+            expect(commandStack.canRedo()).to.be.false;
+            expect(commandStack.isDirty).to.be.false;
+        });
+
+        it('should redo the command and become dirty again', () => {
+            commandStack['commands'].push(command1);
+            commandStack['top'] = -1;
+            expect(commandStack.isDirty).to.be.false;
+            expect(commandStack.canUndo()).to.be.false;
+            expect(commandStack.canRedo()).to.be.true;
+
+            commandStack.redo();
+            expect(command1.redo.calledOnce).to.be.true;
+            expect(commandStack.isDirty).to.be.true;
+            expect(commandStack.canRedo()).to.be.false;
+            expect(commandStack.canUndo()).to.be.true;
+        });
+
+        it('should undo multiple command and become non-dirty again', () => {
+            commandStack['commands'].push(command2, command1);
+            commandStack['top'] = -1;
+            commandStack['saveIndex'] = -1;
+            expect(commandStack.isDirty).to.be.false;
+            expect(commandStack.canUndo()).to.be.false;
+            expect(commandStack.canRedo()).to.be.true;
+
+            commandStack.redo();
+            expect(command2.redo.calledOnce).to.be.true;
+            expect(commandStack.canRedo()).to.be.true;
+            expect(commandStack.canUndo()).to.be.true;
+            expect(commandStack.isDirty).to.be.true;
+
+            commandStack.redo();
+            expect(command1.redo.calledOnce).to.be.true;
+            expect(command1.redo.calledAfter(command2.redo)).to.be.true;
+            expect(commandStack.isDirty).to.be.true;
+            expect(commandStack.canRedo()).to.be.false;
+            expect(commandStack.canUndo()).to.be.true;
+        });
+        it('should flush the stack in case of an execution error', () => {
+            command2.redo.throwsException();
+            const flushSpy = sandbox.spy(commandStack, 'flush');
+            commandStack['commands'].push(command2);
+            commandStack['top'] = -1;
+
+            expect(() => commandStack.redo()).to.throw();
+            expect(command2.redo.calledOnce).to.be.true;
+            expect(flushSpy.calledOnce).to.be.true;
+        });
+        it('should be able to undo after redo', () => {
+            commandStack['commands'].push(command1);
+            commandStack['top'] = -1;
+            expect(commandStack.canUndo()).to.be.false;
+            commandStack.redo();
+            expect(commandStack.canUndo()).to.be.true;
+        });
+    });
+
+    describe('flush', () => {
+        it('should reset the internal state of the command stack', () => {
+            commandStack['commands'].push(command1, command1);
+            commandStack['top'] = 0;
+
+            commandStack.flush();
+            expect(commandStack.isDirty).to.be.false;
+            expect(commandStack.canUndo()).to.be.false;
+            expect(commandStack.canRedo()).to.be.false;
+        });
+    });
+
+    describe('isSaveDone', () => {
+        it('should become non-dirty after execution', () => {
+            commandStack['commands'].push(command1);
+            commandStack['top'] = 0;
+            expect(commandStack.isDirty).to.be.true;
+
+            commandStack.saveIsDone();
+            expect(commandStack.isDirty).to.be.false;
+        });
+        it('should maintain undo/redo history after execution', () => {
+            commandStack['commands'].push(command1, command2);
+            commandStack['top'] = 0;
+            expect(commandStack.canUndo()).to.be.true;
+            expect(commandStack.canRedo()).to.be.true;
+
+            commandStack.saveIsDone();
+            expect(commandStack.canUndo()).to.be.true;
+            expect(commandStack.canRedo()).to.be.true;
+        });
+    });
+});

package/src/common/command/command-stack.ts

@@ -0,0 +1,159 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import { Logger } from '../utils/logger';
+import { Command } from './command';
+
+export const CommandStack = Symbol('CommandStack');
+
+/**
+ * A command stack keeps track of {@link Command commands} that have been executed.
+ * Executed commands can be undone in the reverse order of their original execution.
+ * Unless a new command has been executed after an undo operation, commands can be
+ * redone in the original order of their execution.
+ *
+ */
+export interface CommandStack {
+    /**
+     * Clears any redoable commands not yet redone, adds the command to the stack and then invokes {@link Command.execute}.
+     * @param command the command to execute.
+     */
+    execute(command: Command): void;
+
+    /**
+     * Removes the topmost (i.e. last executed) command from the stack and invokes {@link Command.undo}.
+     */
+    undo(): void;
+
+    /**
+     * Returns `true` if the top command on the stack can be undone.
+     */
+    canUndo(): boolean;
+
+    /**
+     * Re-adds the last undo command on top of the stack and invokes {@link Command.redo}
+     */
+    redo(): void;
+
+    /**
+     * Returns `true` if there are  redoable commands in the stack.
+     */
+    canRedo(): boolean;
+
+    /**
+     * Called after a save has been successfully performed.
+     */
+    saveIsDone(): void;
+
+    /**
+     * Indicates wether the command stack has unsaved changes.
+     */
+    readonly isDirty: boolean;
+
+    /**
+     * Disposes all the commands in the stack.
+     */
+    flush(): void;
+}
+
+@injectable()
+export class DefaultCommandStack implements CommandStack {
+    @inject(Logger)
+    protected logger: Logger;
+
+    protected commands: Command[] = [];
+
+    /**
+     * The current position within the command list from which the next execute, undo, or redo, will be performed.
+     */
+    protected top = -1;
+
+    /**
+     * The current position within the command list when {@link DefaultCommandStack.saveIsDone} is called.
+     */
+    protected saveIndex = -1;
+
+    execute(command: Command): void {
+        try {
+            command.execute();
+        } catch (error) {
+            this.handleError(error);
+        }
+        // Clear the command list past the top (i.e. the old redo list)
+        this.commands = this.commands.slice(0, this.top + 1);
+        this.commands.push(command);
+        ++this.top;
+
+        // if the saveIndex points to the old redo list we can never reach a state again
+        // where save is not necessary. => ensure that `isDirty` always returns true
+        if (this.saveIndex >= this.top) {
+            this.saveIndex = -2;
+        }
+    }
+
+    undo(): void {
+        if (this.canUndo()) {
+            const command = this.commands[this.top--];
+            try {
+                command.undo();
+            } catch (error) {
+                this.handleError(error);
+            }
+        }
+    }
+
+    canUndo(): boolean {
+        return this.top !== -1 //
+            ? Command.canUndo(this.commands[this.top])
+            : false;
+    }
+
+    redo(): void {
+        if (this.canRedo()) {
+            const command = this.commands[++this.top];
+            try {
+                command.redo();
+            } catch (error) {
+                this.handleError(error);
+            }
+        }
+    }
+
+    canRedo(): boolean {
+        return this.top < this.commands.length - 1;
+    }
+
+    get isDirty(): boolean {
+        return this.saveIndex !== this.top;
+    }
+
+    saveIsDone(): void {
+        this.saveIndex = this.top;
+    }
+
+    flush(): void {
+        this.commands = [];
+        this.top = -1;
+        this.saveIndex = -1;
+    }
+
+    protected handleError(error: any): never {
+        // if an error occurred during the command execution the stack might be in an erroneous state => we have to flush the command stack
+        this.flush();
+        this.logger.error('An error occurred during command execution. CommandStack will be flushed!', error);
+        throw error;
+    }
+}