@eclipse-glsp/server 1.1.0-RC05

package/src/common/features/directediting/context-edit-validator-registry.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * 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, multiInject, optional } from 'inversify';
+import { ContextEditValidators } from '../../di/service-identifiers';
+import { Registry } from '../../utils/registry';
+import { ModelState } from '../model/model-state';
+import { ContextEditValidator, ValidateLabelEditAdapter } from './context-edit-validator';
+import { LabelEditValidator } from './label-edit-validator';
+
+export const ContextEditValidatorRegistry = Symbol.for('ContextEditValidatorRegistry');
+
+/**
+ * A registry that keeps track of all registered {@link ContextEditValidator}s.
+ */
+export interface ContextEditValidatorRegistry extends Registry<string, ContextEditValidator> {}
+
+@injectable()
+export class DefaultContextEditValidatorRegistry extends Registry<string, ContextEditValidator> implements ContextEditValidatorRegistry {
+    constructor(
+        @inject(ModelState) modelState: ModelState,
+        @multiInject(ContextEditValidators) @optional() contextEditValidators: ContextEditValidator[] = [],
+        @inject(LabelEditValidator) @optional() labelEditValidator?: LabelEditValidator
+    ) {
+        super();
+        contextEditValidators.forEach(provider => this.register(provider.contextId, provider));
+        if (labelEditValidator) {
+            this.register(LabelEditValidator.CONTEXT_ID, new ValidateLabelEditAdapter(modelState, labelEditValidator));
+        }
+    }
+}

package/src/common/features/directediting/context-edit-validator.ts

@@ -0,0 +1,55 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/graph/lib/gmodel-element';
+import { RequestEditValidationAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { ModelState } from '../model/model-state';
+import { LabelEditValidator } from './label-edit-validator';
+
+export const ContextEditValidator = Symbol('ContextEditValidator');
+
+export interface ContextEditValidator {
+    /**
+     * Returns the context id of the {@link ContextActionsProvider}.
+     */
+    contextId: string;
+
+    /**
+     * Returns the {@link ValidationStatus} for a given {@link RequestEditValidationAction}.
+     *
+     * @param action The RequestEditValidationAction to validate.
+     * @returns The {@link ValidationStatus} for a given {@link RequestEditValidationAction}.
+     */
+    validate(action: RequestEditValidationAction): ValidationStatus;
+}
+
+export class ValidateLabelEditAdapter implements ContextEditValidator {
+    labelEditValidator: LabelEditValidator;
+    constructor(readonly modelState: ModelState, labelEditValidator: LabelEditValidator) {
+        this.labelEditValidator = labelEditValidator;
+    }
+
+    get contextId(): string {
+        return LabelEditValidator.CONTEXT_ID;
+    }
+
+    validate(action: RequestEditValidationAction): ValidationStatus {
+        const element = this.modelState.index.get(action.modelElementId);
+        if (element instanceof GModelElement) {
+            return this.labelEditValidator.validate(action.text, element);
+        }
+        return { severity: ValidationStatus.Severity.OK };
+    }
+}

package/src/common/features/directediting/label-edit-validator.ts

@@ -0,0 +1,35 @@
+/********************************************************************************
+ * 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 { GModelElement } from '@eclipse-glsp/graph';
+import { ValidationStatus } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+
+/**
+ * A validator that validates a new label for a given {@link GModelElement}.
+ */
+@injectable()
+export abstract class LabelEditValidator {
+    static readonly CONTEXT_ID = 'label-edit';
+
+    /**
+     * Returns the {@link ValidationStatus} for a given edited label of a {@link GModelElement}.
+     *
+     * @param label   The edited label to validate.
+     * @param element The element for which the label is going to be edited.
+     * @returns The {@link ValidationStatus} of the label.
+     */
+    abstract validate(label: string, element: GModelElement): ValidationStatus;
+}

package/src/common/features/directediting/request-edit-validation-handler.spec.ts

@@ -0,0 +1,131 @@
+/********************************************************************************
+ * 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 { GNode } from '@eclipse-glsp/graph';
+import { RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { TestContextEditValidator, TestLabelEditValidator } from '../../test/mock-util';
+import { GModelIndex } from '../model/gmodel-index';
+import { DefaultModelState } from '../model/model-state';
+import { ContextEditValidator } from './context-edit-validator';
+import { DefaultContextEditValidatorRegistry } from './context-edit-validator-registry';
+import { LabelEditValidator } from './label-edit-validator';
+import { RequestEditValidationHandler } from './request-edit-validation-handler';
+
+describe('Test RequestEditValidationHandler', () => {
+    const contextEditValidators: ContextEditValidator[] = [new TestContextEditValidator()];
+    const modelState = new DefaultModelState();
+    Object.defineProperty(modelState, 'index', { value: new GModelIndex() });
+    sinon.stub(modelState.index, 'get').callsFake(() => new GNode());
+    const contextEditValidatorsRegistry = new DefaultContextEditValidatorRegistry(
+        modelState,
+        contextEditValidators,
+        new TestLabelEditValidator()
+    );
+
+    const requestEditValidationHandler = new RequestEditValidationHandler();
+    requestEditValidationHandler['contextEditValidatorRegistry'] = contextEditValidatorsRegistry;
+
+    it('requestContextEditValidation with ok result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'ok' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.OK);
+        expect(status.message).to.be.equal('ok');
+    });
+
+    it('requestContextEditValidation with warning result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'warning' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.WARNING);
+        expect(status.message).to.be.equal('warning');
+    });
+
+    it('requestContextEditValidation with error result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: 'test', modelElementId: '', text: 'error' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.ERROR);
+        expect(status.message).to.be.equal('error');
+    });
+
+    it('requestLabelEditValidation with ok result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'ok' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.OK);
+        expect(status.message).to.be.equal('ok');
+    });
+
+    it('requestLabelEditValidation with warning result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'warning' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.WARNING);
+        expect(status.message).to.be.equal('warning');
+    });
+
+    it('requestLabelEditValidation with error result', async () => {
+        const actions = await requestEditValidationHandler.execute(
+            RequestEditValidationAction.create({ contextId: LabelEditValidator.CONTEXT_ID, modelElementId: '', text: 'error' })
+        );
+        expect(actions).to.have.length(1);
+        const action = actions[0];
+
+        expect(SetEditValidationResultAction.is(action)).to.be.true;
+        const setEditValidationResultAction = action as SetEditValidationResultAction;
+        const status = setEditValidationResultAction.status;
+
+        expect(status.severity).to.be.equal(ValidationStatus.Severity.ERROR);
+        expect(status.message).to.be.equal('error');
+    });
+});

package/src/common/features/directediting/request-edit-validation-handler.ts

@@ -0,0 +1,43 @@
+/********************************************************************************
+ * 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, MaybePromise, RequestEditValidationAction, SetEditValidationResultAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { Logger } from '../../utils/logger';
+import { ContextEditValidatorRegistry } from './context-edit-validator-registry';
+
+@injectable()
+export class RequestEditValidationHandler implements ActionHandler {
+    actionKinds = [RequestEditValidationAction.KIND];
+
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(ContextEditValidatorRegistry)
+    contextEditValidatorRegistry: ContextEditValidatorRegistry;
+
+    execute(action: RequestEditValidationAction): MaybePromise<Action[]> {
+        const validator = this.contextEditValidatorRegistry.get(action.contextId);
+        if (validator) {
+            const validationStatus = validator.validate(action);
+            return [SetEditValidationResultAction.create(validationStatus)];
+        } else {
+            const message = `No validator registered for the context '${action.contextId}'`;
+            this.logger.warn(message);
+            return [SetEditValidationResultAction.create({ severity: ValidationStatus.Severity.WARNING, message: message })];
+        }
+    }
+}

package/src/common/features/layout/computed-bounds-action-handler.ts

@@ -0,0 +1,56 @@
+/********************************************************************************
+ * 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 { GModelRoot } from '@eclipse-glsp/graph';
+import { Action, ComputedBoundsAction, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { applyAlignment, applyBounds, applyRoute } from '../../utils/layout-util';
+import { ModelState } from '../model/model-state';
+import { ModelSubmissionHandler } from '../model/model-submission-handler';
+
+/**
+ * Syncs the bounds computed by the client (i.e. the actual bounds after applying CSS styles) back to the `GModel`.
+ * In this default implementation the updated bounds are stored transient. This means they are applied to the graphical model but
+ * are not persisted to the source model.
+ */
+@injectable()
+export class ComputedBoundsActionHandler implements ActionHandler {
+    @inject(ModelSubmissionHandler)
+    protected submissionHandler: ModelSubmissionHandler;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    actionKinds = [ComputedBoundsAction.KIND];
+    execute(action: ComputedBoundsAction): MaybePromise<Action[]> {
+        const model = this.modelState.root;
+        if (action.revision === model.revision) {
+            this.applyBounds(model, action);
+            return this.submissionHandler.submitModelDirectly();
+        }
+
+        return [];
+    }
+
+    protected applyBounds(root: GModelRoot, action: ComputedBoundsAction): void {
+        const index = this.modelState.index;
+        action.bounds.forEach(bounds => applyBounds(bounds, index));
+        (action.alignments ?? []).forEach(alignment => applyAlignment(alignment, index));
+        (action.routes ?? []).forEach(route => applyRoute(route, index));
+    }
+
+    priority?: number | undefined;
+}

package/src/common/features/layout/layout-engine.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * 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 { GModelRoot } from '@eclipse-glsp/graph';
+import { MaybePromise } from '@eclipse-glsp/protocol';
+
+/**
+ * A layout engine is able to compute layout information for a model.
+ */
+export interface LayoutEngine {
+    /**
+     * Computes a layout for the model state and modify the model accordingly.
+     * @returns the layouted {@link GModelRoot}.
+     */
+    layout(): MaybePromise<GModelRoot>;
+}
+
+export const LayoutEngine = Symbol('LayoutEngine');

package/src/common/features/layout/layout-operation-handler.ts

@@ -0,0 +1,62 @@
+/********************************************************************************
+ * 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 { LayoutOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { Command } from '../../command/command';
+import { GModelRecordingCommand } from '../../command/recording-command';
+import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
+import { OperationHandler } from '../../operations/operation-handler';
+import { Logger } from '../../utils/logger';
+import { GModelSerializer } from '../model/gmodel-serializer';
+import { LayoutEngine } from './layout-engine';
+
+/**
+ * The default handler for `{@link LayoutOperation}s. Does invoke the (optional) layout engine
+ * if the server is configured for manual layouting. Changes are stored transient in the graphical model and are not
+ * persisted in the source model.
+ */
+@injectable()
+export class LayoutOperationHandler extends OperationHandler {
+    @inject(Logger)
+    protected logger: Logger;
+
+    @inject(LayoutEngine)
+    @optional()
+    protected layoutEngine?: LayoutEngine;
+
+    @inject(DiagramConfiguration)
+    protected diagramConfiguration: DiagramConfiguration;
+
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
+    readonly operationType = LayoutOperation.KIND;
+
+    createCommand(operation: LayoutOperation): MaybePromise<Command | undefined> {
+        if (this.diagramConfiguration.layoutKind !== ServerLayoutKind.MANUAL) {
+            return undefined;
+        }
+        if (!this.layoutEngine) {
+            this.logger.warn('Could not execute layout operation. No `LayoutEngine` is bound!');
+            return undefined;
+        }
+        return new GModelRecordingCommand(this.modelState, this.serializer, () => this.executeOperation(operation));
+    }
+
+    protected async executeOperation(_operation: Operation): Promise<void> {
+        await this.layoutEngine?.layout();
+    }
+}

package/src/common/features/model/gmodel-factory.ts

@@ -0,0 +1,60 @@
+/********************************************************************************
+ * 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';
+
+export const GModelFactory = Symbol('GModelFactory');
+
+/**
+ * A graph model factory produces a graph model from the model state; typically its contained source model.
+ *
+ * The responsibility of a {@link GModelFactory} implementation is to define how a {@link ModelState} is to be
+ * translated into a {@link GModelRoot} that is sent to the client for rendering. Before a {@link GModelFactory}
+ * is invoked, the {@link SourceModelStorage} has already been executed for loading the source model into the
+ * {@link ModelState}. The {@link GModelFactory} then produces the {@link GModelRoot} from the source model in the
+ * {@link ModelState}. Implementations of {@link GModelFactory} are usually specific to the type of source model, as
+ * they need to understand the source model in order to translate it into a graph model.
+ *
+ * The graph model factory is invoked after initial load of the source model and after each operation that is applied
+ * to the source model by an {@link OperationHandler} in order to update the graph model before sending it to the client
+ * for rendering.
+ *
+ * If an index is needed for mapping between the graph model and the source model, as is typically the case for
+ * {@link ActionHandler action handlers} and {@link OperationHandler operation handlers}, it is the responsibility of
+ * the graph model factory to create such an index while producing the graph model from the source model. The index
+ * shall be put into the model state too. Typically the {@link GModelIndex} is extended for a particular model source
+ * type as well.
+ *
+ * @see SourceModelStorage
+ * @see GModelIndex
+ */
+export interface GModelFactory {
+    /**
+     * Create a {@link GModelRoot} from the specified <code>modelState</code> and puts it into the
+     * <code>modelState</code>. Optionally, this step also produces and sets a {@link GModelIndex} in the model state
+     * that allows mapping from graph model elements to source model elements and vice versa.
+     */
+    createModel(): void;
+}
+
+/**
+ * GModelFactory to be used if the graph model is already available from the model source.
+ */
+@injectable()
+export class GModelFactoryNullImpl implements GModelFactory {
+    createModel(): void {
+        // no-op
+    }
+}