@finos/legend-application-studio 13.0.0

package/src/stores/editor-state/entity-diff-editor-state/EntityChangeConflictEditorState.ts

@@ -0,0 +1,547 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  observable,
+  action,
+  flow,
+  computed,
+  makeObservable,
+  flowResult,
+} from 'mobx';
+import type { EditorStore } from '../../EditorStore.js';
+import {
+  type SPECIAL_REVISION_ALIAS,
+  EntityDiffEditorState,
+} from './EntityDiffEditorState.js';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { mergeDiff3 } from 'node-diff3';
+import { type Entity, extractEntityNameFromPath } from '@finos/legend-storage';
+import { EntityChangeConflictResolution } from '@finos/legend-server-sdlc';
+import { ParserError } from '@finos/legend-graph';
+import type { AbstractConflictResolutionState } from '../../AbstractConflictResolutionState.js';
+
+const START_HEADER_MARKER = '<<<<<<<';
+const COMMON_BASE_MARKER = '|||||||';
+const SPLITTER_MARKER = '=======';
+const END_FOOTER_MARKER = '>>>>>>>';
+
+interface PotentialMergeConflict {
+  startHeader: number;
+  commonBase?: number | undefined;
+  splitter?: number | undefined;
+  endFooter?: number | undefined;
+}
+
+export interface MergeConflict {
+  startHeader: number;
+  commonBase?: number | undefined;
+  splitter: number;
+  endFooter: number;
+}
+
+const scanMergeConflict = (text: string): MergeConflict[] => {
+  const lines = text.split('\n');
+  const conflicts: MergeConflict[] = [];
+  let currentConflict: PotentialMergeConflict | null = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+
+    // ignore empty lines
+    if (!line || !line.trim()) {
+      continue;
+    }
+
+    // Is this a start line? <<<<<<<
+    if (line.startsWith(START_HEADER_MARKER)) {
+      if (currentConflict !== null) {
+        // Give up parsing, anything matched up this to this point will be decorated
+        // anything after will not
+        break;
+      }
+
+      // Create a new conflict starting at this line
+      currentConflict = { startHeader: lineNumber };
+    } else if (
+      currentConflict &&
+      !currentConflict.splitter &&
+      line.startsWith(COMMON_BASE_MARKER)
+    ) {
+      // Are we within a conflict block and is this a common ancestors marker? |||||||
+      currentConflict.commonBase = lineNumber;
+    } else if (
+      currentConflict &&
+      !currentConflict.splitter &&
+      line.startsWith(SPLITTER_MARKER)
+    ) {
+      // Are we within a conflict block and is this a splitter? =======
+      currentConflict.splitter = lineNumber;
+    } else if (currentConflict && line.startsWith(END_FOOTER_MARKER)) {
+      // Are we within a conflict block and is this a footer? >>>>>>>
+      currentConflict.endFooter = lineNumber;
+
+      if (currentConflict.splitter !== undefined) {
+        conflicts.push(currentConflict as MergeConflict);
+      }
+
+      // Reset the current conflict to be empty, so we can match the next
+      // starting header marker.
+      currentConflict = null;
+    }
+  }
+
+  return conflicts;
+};
+
+export interface MergeEditorComparisonViewInfo {
+  label: string;
+  fromGrammarText?: string | undefined;
+  toGrammarText?: string | undefined;
+  fromRevision: SPECIAL_REVISION_ALIAS | string;
+  toRevision: SPECIAL_REVISION_ALIAS | string;
+}
+
+export enum ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE {
+  MERGE_VIEW = 'MERGE_VIEW',
+  BASE_CURRENT = 'BASE_CURRENT',
+  BASE_INCOMING = 'BASE_INCOMING',
+  CURRENT_INCOMING = 'CURRENT_INCOMING',
+}
+
+export class EntityChangeConflictEditorState extends EntityDiffEditorState {
+  entityPath: string;
+  // revision
+  baseRevision: SPECIAL_REVISION_ALIAS | string;
+  currentChangeRevision: SPECIAL_REVISION_ALIAS | string;
+  incomingChangeRevision: SPECIAL_REVISION_ALIAS | string;
+  // entity
+  baseEntity?: Entity | undefined;
+  currentChangeEntity?: Entity | undefined;
+  incomingChangeEntity?: Entity | undefined;
+  // grammar
+  baseGrammarText?: string | undefined;
+  currentChangeGrammarText?: string | undefined;
+  incomingChangeGrammarText?: string | undefined;
+  // entity getter/updater function
+  baseEntityGetter?:
+    | ((entityPath: string | undefined) => Entity | undefined)
+    | undefined;
+  currentChangeEntityGetter?:
+    | ((entityPath: string | undefined) => Entity | undefined)
+    | undefined;
+  incomingChangeEntityGetter?:
+    | ((entityPath: string | undefined) => Entity | undefined)
+    | undefined;
+  // editor
+  mergedText?: string | undefined;
+  mergeSucceeded = true;
+  mergeConflicts: MergeConflict[] = [];
+  isReadOnly = false;
+  currentMergeEditorConflict?: MergeConflict | undefined;
+  currentMergeEditorLine?: number | undefined;
+  mergeEditorParserError?: ParserError | undefined;
+  currentMode = ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.MERGE_VIEW;
+  conflictResolutionState: AbstractConflictResolutionState;
+
+  constructor(
+    editorStore: EditorStore,
+    conflictResolutionState: AbstractConflictResolutionState,
+    entityPath: string,
+    baseRevision: SPECIAL_REVISION_ALIAS | string,
+    currentChangeRevision: SPECIAL_REVISION_ALIAS | string,
+    incomingChangeRevision: SPECIAL_REVISION_ALIAS | string,
+    baseEntity: Entity | undefined,
+    currentChangeEntity: Entity | undefined,
+    incomingChangeEntity: Entity | undefined,
+    baseEntityGetter?: (entityPath: string | undefined) => Entity | undefined,
+    currentChangeEntityGetter?: (
+      entityPath: string | undefined,
+    ) => Entity | undefined,
+    incomingChangeEntityGetter?: (
+      entityPath: string | undefined,
+    ) => Entity | undefined,
+  ) {
+    super(editorStore);
+
+    makeObservable<
+      EntityChangeConflictEditorState,
+      'sortedMergedConflicts' | 'getGrammarForEntity'
+    >(this, {
+      entityPath: observable,
+      baseRevision: observable,
+      currentChangeRevision: observable,
+      incomingChangeRevision: observable,
+      baseEntity: observable.ref,
+      currentChangeEntity: observable.ref,
+      incomingChangeEntity: observable.ref,
+      baseGrammarText: observable,
+      currentChangeGrammarText: observable,
+      incomingChangeGrammarText: observable,
+      baseEntityGetter: observable,
+      currentChangeEntityGetter: observable,
+      incomingChangeEntityGetter: observable,
+      mergedText: observable,
+      mergeSucceeded: observable,
+      mergeConflicts: observable,
+      isReadOnly: observable,
+      currentMergeEditorConflict: observable,
+      currentMergeEditorLine: observable,
+      mergeEditorParserError: observable,
+      currentMode: observable,
+      headerName: computed,
+      sortedMergedConflicts: computed,
+      canUseTheirs: computed,
+      canUseYours: computed,
+      canMarkAsResolved: computed,
+      previousConflict: computed,
+      nextConflict: computed,
+      setReadOnly: action,
+      setMergedText: action,
+      setCurrentMode: action,
+      setCurrentMergeEditorLine: action,
+      setCurrentMergeEditorConflict: action,
+      clearMergeEditorError: action,
+      refreshMergeConflict: action,
+      resetMergeEditorStateOnLeave: action,
+      acceptCurrentChange: action,
+      acceptIncomingChange: action,
+      acceptBothChanges: action,
+      rejectBothChanges: action,
+      refresh: flow,
+      getMergedText: flow,
+      markAsResolved: flow,
+      useCurrentChanges: flow,
+      useIncomingChanges: flow,
+      getGrammarForEntity: flow,
+    });
+
+    this.entityPath = entityPath;
+    // revision
+    this.baseRevision = baseRevision;
+    this.currentChangeRevision = currentChangeRevision;
+    this.incomingChangeRevision = incomingChangeRevision;
+    // entity
+    this.baseEntity = baseEntity;
+    this.currentChangeEntity = currentChangeEntity;
+    this.incomingChangeEntity = incomingChangeEntity;
+    // entity getter/updater function
+    this.baseEntityGetter = baseEntityGetter;
+    this.currentChangeEntityGetter = currentChangeEntityGetter;
+    this.incomingChangeEntityGetter = incomingChangeEntityGetter;
+    this.conflictResolutionState = conflictResolutionState;
+  }
+
+  setReadOnly(val: boolean): void {
+    this.isReadOnly = val;
+  }
+  setMergedText(val: string): void {
+    this.mergedText = val;
+  }
+  setCurrentMode(mode: ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE): void {
+    this.currentMode = mode;
+  }
+  setCurrentMergeEditorLine(val: number | undefined): void {
+    this.currentMergeEditorLine = val;
+  }
+  setCurrentMergeEditorConflict(conflict: MergeConflict | undefined): void {
+    this.currentMergeEditorConflict = conflict;
+  }
+  clearMergeEditorError(): void {
+    this.mergeEditorParserError = undefined;
+  }
+
+  refreshMergeConflict(): void {
+    if (this.mergedText !== undefined) {
+      this.mergeConflicts = scanMergeConflict(this.mergedText);
+    }
+  }
+
+  get headerName(): string {
+    return extractEntityNameFromPath(this.entityPath);
+  }
+  private get sortedMergedConflicts(): MergeConflict[] {
+    return this.mergeConflicts
+      .slice()
+      .sort((a, b) => a.startHeader - b.startHeader);
+  }
+  get canUseTheirs(): boolean {
+    return (
+      this.currentMode !== ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.BASE_CURRENT
+    );
+  }
+  get canUseYours(): boolean {
+    return (
+      this.currentMode !== ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.BASE_INCOMING
+    );
+  }
+  get canMarkAsResolved(): boolean {
+    return Boolean(
+      !this.mergeConflicts.length &&
+        !this.mergeEditorParserError &&
+        this.currentMode === ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.MERGE_VIEW,
+    );
+  }
+
+  get previousConflict(): MergeConflict | undefined {
+    const currentLine = this.currentMergeEditorLine ?? 0;
+    return this.sortedMergedConflicts
+      .slice()
+      .reverse()
+      .find(
+        (conflict) => conflict.endFooter && conflict.endFooter < currentLine,
+      );
+  }
+
+  get nextConflict(): MergeConflict | undefined {
+    const currentLine = this.currentMergeEditorLine ?? 0;
+    return this.sortedMergedConflicts.find(
+      (conflict) => conflict.startHeader > currentLine,
+    );
+  }
+
+  getModeComparisonViewInfo(
+    mode: ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE,
+  ): MergeEditorComparisonViewInfo {
+    switch (mode) {
+      case ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.MERGE_VIEW:
+        return {
+          label: 'Merged changes',
+          fromRevision: this.currentChangeRevision,
+          toRevision: this.incomingChangeRevision,
+        };
+      case ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.BASE_CURRENT:
+        return {
+          label: 'Your changes',
+          fromGrammarText: this.baseGrammarText ?? '',
+          toGrammarText: this.currentChangeGrammarText ?? '',
+          fromRevision: this.baseRevision,
+          toRevision: this.currentChangeRevision,
+        };
+      case ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.BASE_INCOMING:
+        return {
+          label: 'Their changes',
+          fromGrammarText: this.baseGrammarText ?? '',
+          toGrammarText: this.incomingChangeGrammarText ?? '',
+          fromRevision: this.baseRevision,
+          toRevision: this.incomingChangeRevision,
+        };
+      case ENTITY_CHANGE_CONFLICT_EDITOR_VIEW_MODE.CURRENT_INCOMING:
+        return {
+          label: 'Both changes',
+          fromGrammarText: this.currentChangeGrammarText ?? '',
+          toGrammarText: this.incomingChangeGrammarText ?? '',
+          fromRevision: this.currentChangeRevision,
+          toRevision: this.incomingChangeRevision,
+        };
+      default:
+        throw new UnsupportedOperationError();
+    }
+  }
+
+  resetMergeEditorStateOnLeave(): void {
+    this.clearMergeEditorError();
+    this.currentMergeEditorLine = undefined;
+    this.currentMergeEditorConflict = undefined;
+  }
+
+  *refresh(): GeneratorFn<void> {
+    this.baseEntity = this.baseEntityGetter
+      ? this.baseEntityGetter(this.entityPath)
+      : this.baseEntity;
+    this.currentChangeEntity = this.currentChangeEntityGetter
+      ? this.currentChangeEntityGetter(this.entityPath)
+      : this.currentChangeEntity;
+    this.incomingChangeEntity = this.incomingChangeEntityGetter
+      ? this.incomingChangeEntityGetter(this.entityPath)
+      : this.incomingChangeEntity;
+    if (this.isReadOnly || this.mergedText === undefined) {
+      yield flowResult(this.getMergedText());
+    }
+  }
+
+  *getMergedText(): GeneratorFn<void> {
+    this.baseGrammarText = (yield flowResult(
+      this.getGrammarForEntity(this.baseEntity),
+    )) as string;
+    this.currentChangeGrammarText = (yield flowResult(
+      this.getGrammarForEntity(this.currentChangeEntity),
+    )) as string;
+    this.incomingChangeGrammarText = (yield flowResult(
+      this.getGrammarForEntity(this.incomingChangeEntity),
+    )) as string;
+    const result = mergeDiff3<string>(
+      this.currentChangeGrammarText,
+      this.baseGrammarText,
+      this.incomingChangeGrammarText,
+      {
+        stringSeparator: '\n',
+        label: { a: 'Your Change', o: 'BASE', b: 'Their Change' },
+      },
+    );
+    this.mergedText = result.result.join('\n');
+    this.refreshMergeConflict();
+    this.mergeSucceeded = !this.mergeConflicts.length;
+  }
+
+  private *getGrammarForEntity(
+    entity: Entity | undefined,
+  ): GeneratorFn<string> {
+    if (entity) {
+      const elementGrammar =
+        (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
+          [entity],
+        )) as string;
+      return elementGrammar;
+    }
+    return '';
+  }
+
+  *markAsResolved(): GeneratorFn<void> {
+    try {
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.pureCodeToEntities(
+          this.mergedText ?? '',
+        )) as Entity[];
+      if (!entities.length) {
+        this.conflictResolutionState.resolveConflict(
+          new EntityChangeConflictResolution(this.entityPath, undefined),
+        );
+      } else if (entities.length === 1) {
+        this.conflictResolutionState.resolveConflict(
+          new EntityChangeConflictResolution(
+            this.entityPath,
+            entities[0] as Entity,
+          ),
+        );
+      } else {
+        this.editorStore.applicationStore.notifyWarning(
+          `Can't mark conflict as resolved: more than one element found in parsed text`,
+        );
+        return;
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      if (error instanceof ParserError) {
+        this.mergeEditorParserError = error;
+        this.editorStore.applicationStore.notifyWarning(
+          `Can't mark conflict as resolved. Parsing error: ${this.mergeEditorParserError.message}`,
+        );
+      }
+    }
+    yield flowResult(this.conflictResolutionState.markConflictAsResolved(this));
+  }
+
+  *useCurrentChanges(): GeneratorFn<void> {
+    this.conflictResolutionState.resolveConflict(
+      new EntityChangeConflictResolution(
+        this.entityPath,
+        this.currentChangeEntity,
+      ),
+    );
+    yield flowResult(this.conflictResolutionState.markConflictAsResolved(this));
+  }
+
+  *useIncomingChanges(): GeneratorFn<void> {
+    this.conflictResolutionState.resolveConflict(
+      new EntityChangeConflictResolution(
+        this.entityPath,
+        this.incomingChangeEntity,
+      ),
+    );
+    yield flowResult(this.conflictResolutionState.markConflictAsResolved(this));
+  }
+
+  acceptCurrentChange(conflict: MergeConflict): void {
+    if (this.mergedText === undefined) {
+      return;
+    }
+    const lines = this.mergedText.split('\n');
+    this.setMergedText(
+      lines
+        .slice(0, conflict.startHeader - 1)
+        .concat(
+          lines.slice(
+            conflict.startHeader,
+            (conflict.commonBase ?? conflict.splitter) - 1,
+          ),
+        ) // current change
+        .concat(lines.slice(conflict.endFooter, lines.length))
+        .join('\n'),
+    );
+    this.refreshMergeConflict();
+  }
+
+  acceptIncomingChange(conflict: MergeConflict): void {
+    if (this.mergedText === undefined) {
+      return;
+    }
+    const lines = this.mergedText.split('\n');
+    this.setMergedText(
+      lines
+        .slice(0, conflict.startHeader - 1)
+        .concat(lines.slice(conflict.splitter, conflict.endFooter - 1)) // incoming change
+        .concat(lines.slice(conflict.endFooter, lines.length))
+        .join('\n'),
+    );
+    this.refreshMergeConflict();
+  }
+
+  acceptBothChanges(conflict: MergeConflict): void {
+    if (this.mergedText === undefined) {
+      return;
+    }
+    const lines = this.mergedText.split('\n');
+    this.setMergedText(
+      lines
+        .slice(0, conflict.startHeader - 1)
+        .concat(
+          lines.slice(
+            conflict.startHeader,
+            (conflict.commonBase ?? conflict.splitter) - 1,
+          ),
+        ) // current change
+        .concat(lines.slice(conflict.splitter, conflict.endFooter - 1)) // incoming change
+        .concat(lines.slice(conflict.endFooter, lines.length))
+        .join('\n'),
+    );
+    this.refreshMergeConflict();
+  }
+
+  rejectBothChanges(conflict: MergeConflict): void {
+    if (this.mergedText === undefined) {
+      return;
+    }
+    const lines = this.mergedText.split('\n');
+    this.setMergedText(
+      lines
+        .slice(0, conflict.startHeader - 1)
+        .concat(
+          conflict.commonBase
+            ? lines.slice(conflict.commonBase, conflict.splitter - 1)
+            : [],
+        ) // base
+        .concat(lines.slice(conflict.endFooter, lines.length))
+        .join('\n'),
+    );
+    this.refreshMergeConflict();
+  }
+}

package/src/stores/editor-state/entity-diff-editor-state/EntityDiffEditorState.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { EditorState } from '../../editor-state/EditorState.js';
+
+export enum SPECIAL_REVISION_ALIAS {
+  LOCAL = 'LOCAL_REVISION',
+  WORKSPACE_BASE = 'WORKSPACE_BASE',
+  WORKSPACE_HEAD = 'WORKSPACE_HEAD',
+  WORKSPACE_UPDATE = 'WORKSPACE_UPDATE',
+  PROJECT_HEAD = 'PROJECT_HEAD',
+}
+
+export const getPrettyLabelForRevision = (
+  revision: SPECIAL_REVISION_ALIAS | string,
+): string => {
+  switch (revision) {
+    case SPECIAL_REVISION_ALIAS.LOCAL:
+      return 'Local';
+    case SPECIAL_REVISION_ALIAS.WORKSPACE_BASE:
+      return 'Workspace BASE';
+    case SPECIAL_REVISION_ALIAS.WORKSPACE_HEAD:
+      return 'Workspace HEAD';
+    case SPECIAL_REVISION_ALIAS.WORKSPACE_UPDATE:
+      return 'Workspace UPDATE';
+    case SPECIAL_REVISION_ALIAS.PROJECT_HEAD:
+      return 'Project HEAD';
+    default:
+      return revision;
+  }
+};
+
+export abstract class EntityDiffEditorState extends EditorState {
+  abstract refresh(): void;
+}