Merge pull request #2857 from github/charisk/initial-modeling-store

Introduce modeling store and move some state there

Author: charisk

extensions/ql-vscode/src/model-editor/methods-usage/methods-usage-panel.ts

@@ -7,12 +7,16 @@ import {
 import { Method, Usage } from "../method";
 import { DatabaseItem } from "../../databases/local-databases";
 import { CodeQLCliServer } from "../../codeql-cli/cli";
+import { ModelingStore } from "../modeling-store";
 
 export class MethodsUsagePanel extends DisposableObject {
   private readonly dataProvider: MethodsUsageDataProvider;
   private readonly treeView: TreeView<MethodsUsageTreeViewItem>;
 
-  public constructor(cliServer: CodeQLCliServer) {
+  public constructor(
+    private readonly modelingStore: ModelingStore,
+    cliServer: CodeQLCliServer,
+  ) {
     super();
 
     this.dataProvider = new MethodsUsageDataProvider(cliServer);
@@ -21,6 +25,8 @@ export class MethodsUsagePanel extends DisposableObject {
       treeDataProvider: this.dataProvider,
     });
     this.push(this.treeView);
+
+    this.registerToModelingStoreEvents();
   }
 
   public async setState(
@@ -44,4 +50,39 @@ export class MethodsUsagePanel extends DisposableObject {
       await this.treeView.reveal(canonicalUsage);
     }
   }
+
+  private registerToModelingStoreEvents(): void {
+    this.push(
+      this.modelingStore.onActiveDbChanged(async () => {
+        await this.handleStateChangeEvent();
+      }),
+    );
+
+    this.push(
+      this.modelingStore.onMethodsChanged(async (event) => {
+        if (event.isActiveDb) {
+          await this.handleStateChangeEvent();
+        }
+      }),
+    );
+
+    this.push(
+      this.modelingStore.onHideModeledMethodsChanged(async (event) => {
+        if (event.isActiveDb) {
+          await this.handleStateChangeEvent();
+        }
+      }),
+    );
+  }
+
+  private async handleStateChangeEvent(): Promise<void> {
+    const activeState = this.modelingStore.getStateForActiveDb();
+    if (activeState !== undefined) {
+      await this.setState(
+        activeState.methods,
+        activeState.databaseItem,
+        activeState.hideModeledMethods,
+      );
+    }
+  }
 }

extensions/ql-vscode/src/model-editor/model-editor-module.ts

@@ -19,16 +19,16 @@ import { showResolvableLocation } from "../databases/local-databases/locations";
 import { Method, Usage } from "./method";
 import { setUpPack } from "./model-editor-queries";
 import { MethodModelingPanel } from "./method-modeling/method-modeling-panel";
+import { ModelingStore } from "./modeling-store";
 
 const SUPPORTED_LANGUAGES: string[] = ["java", "csharp"];
 
 export class ModelEditorModule extends DisposableObject {
   private readonly queryStorageDir: string;
+  private readonly modelingStore: ModelingStore;
   private readonly methodsUsagePanel: MethodsUsagePanel;
   private readonly methodModelingPanel: MethodModelingPanel;
 
-  private mostRecentlyActiveView: ModelEditorView | undefined = undefined;
-
   private constructor(
     private readonly app: App,
     private readonly databaseManager: DatabaseManager,
@@ -38,24 +38,13 @@ export class ModelEditorModule extends DisposableObject {
   ) {
     super();
     this.queryStorageDir = join(baseQueryStorageDir, "model-editor-results");
-    this.methodsUsagePanel = this.push(new MethodsUsagePanel(cliServer));
+    this.modelingStore = new ModelingStore(app);
+    this.methodsUsagePanel = this.push(
+      new MethodsUsagePanel(this.modelingStore, cliServer),
+    );
     this.methodModelingPanel = this.push(new MethodModelingPanel(app));
   }
 
-  private handleViewBecameActive(view: ModelEditorView): void {
-    this.mostRecentlyActiveView = view;
-  }
-
-  private handleViewWasDisposed(view: ModelEditorView): void {
-    if (this.mostRecentlyActiveView === view) {
-      this.mostRecentlyActiveView = undefined;
-    }
-  }
-
-  private isMostRecentlyActiveView(view: ModelEditorView): boolean {
-    return this.mostRecentlyActiveView === view;
-  }
-
   public static async initialize(
     app: App,
     databaseManager: DatabaseManager,
@@ -153,6 +142,7 @@ export class ModelEditorModule extends DisposableObject {
 
             const view = new ModelEditorView(
               this.app,
+              this.modelingStore,
               this.databaseManager,
               this.cliServer,
               this.queryRunner,
@@ -161,16 +151,15 @@ export class ModelEditorModule extends DisposableObject {
               db,
               modelFile,
               Mode.Application,
-              this.methodsUsagePanel.setState.bind(this.methodsUsagePanel),
               this.showMethod.bind(this),
-              this.handleViewBecameActive.bind(this),
-              (view) => {
-                this.handleViewWasDisposed(view);
-                void cleanupQueryDir();
-              },
-              this.isMostRecentlyActiveView.bind(this),
             );
 
+            this.modelingStore.onDbClosed(async (dbUri) => {
+              if (dbUri === db.databaseUri.toString()) {
+                await cleanupQueryDir();
+              }
+            });
+
             this.push(view);
             this.push({
               dispose(): void {

extensions/ql-vscode/src/model-editor/model-editor-view.ts

@@ -41,20 +41,18 @@ import { loadModeledMethods, saveModeledMethods } from "./modeled-method-fs";
 import { pickExtensionPack } from "./extension-pack-picker";
 import { getLanguageDisplayName } from "../common/query-language";
 import { AutoModeler } from "./auto-modeler";
-import { INITIAL_HIDE_MODELED_METHODS_VALUE } from "./shared/hide-modeled-methods";
 import { telemetryListener } from "../common/vscode/telemetry";
+import { ModelingStore } from "./modeling-store";
 
 export class ModelEditorView extends AbstractWebview<
   ToModelEditorMessage,
   FromModelEditorMessage
 > {
   private readonly autoModeler: AutoModeler;
 
-  private methods: Method[];
-  private hideModeledMethods: boolean;
-
   public constructor(
     protected readonly app: App,
+    private readonly modelingStore: ModelingStore,
     private readonly databaseManager: DatabaseManager,
     private readonly cliServer: CodeQLCliServer,
     private readonly queryRunner: QueryRunner,
@@ -63,23 +61,16 @@ export class ModelEditorView extends AbstractWebview<
     private readonly databaseItem: DatabaseItem,
     private readonly extensionPack: ExtensionPack,
     private mode: Mode,
-    private readonly updateMethodsUsagePanelState: (
-      methods: Method[],
-      databaseItem: DatabaseItem,
-      hideModeledMethods: boolean,
-    ) => Promise<void>,
     private readonly showMethod: (
       method: Method,
       usage: Usage,
     ) => Promise<void>,
-    private readonly handleViewBecameActive: (view: ModelEditorView) => void,
-    private readonly handleViewWasDisposed: (view: ModelEditorView) => void,
-    private readonly isMostRecentlyActiveView: (
-      view: ModelEditorView,
-    ) => boolean,
   ) {
     super(app);
 
+    this.modelingStore.initializeStateForDb(databaseItem);
+    this.registerToModelingStoreEvents();
+
     this.autoModeler = new AutoModeler(
       app,
       cliServer,
@@ -97,8 +88,6 @@ export class ModelEditorView extends AbstractWebview<
         await this.postMessage({ t: "addModeledMethods", modeledMethods });
       },
     );
-    this.methods = [];
-    this.hideModeledMethods = INITIAL_HIDE_MODELED_METHODS_VALUE;
   }
 
   public async openView() {
@@ -107,20 +96,15 @@ export class ModelEditorView extends AbstractWebview<
 
     panel.onDidChangeViewState(async () => {
       if (panel.active) {
-        this.handleViewBecameActive(this);
-        await this.updateMethodsUsagePanelState(
-          this.methods,
-          this.databaseItem,
-          this.hideModeledMethods,
-        );
+        this.modelingStore.setActiveDb(this.databaseItem);
         await this.markModelEditorAsActive();
       } else {
         await this.updateModelEditorActiveContext();
       }
     });
 
     panel.onDidDispose(() => {
-      this.handleViewWasDisposed(this);
+      this.modelingStore.removeDb(this.databaseItem);
       // onDidDispose is called after the tab has been closed,
       // so we want to check if there are any others still open.
       void this.app.commands.execute(
@@ -309,11 +293,11 @@ export class ModelEditorView extends AbstractWebview<
         break;
       case "switchMode":
         this.mode = msg.mode;
-        this.methods = [];
+        this.modelingStore.setMethods(this.databaseItem, []);
         await Promise.all([
           this.postMessage({
             t: "setMethods",
-            methods: this.methods,
+            methods: [],
           }),
           this.setViewState(),
           withProgress((progress) => this.loadMethods(progress), {
@@ -324,11 +308,9 @@ export class ModelEditorView extends AbstractWebview<
 
         break;
       case "hideModeledMethods":
-        this.hideModeledMethods = msg.hideModeledMethods;
-        await this.updateMethodsUsagePanelState(
-          this.methods,
+        this.modelingStore.setHideModeledMethods(
           this.databaseItem,
-          this.hideModeledMethods,
+          msg.hideModeledMethods,
         );
         void telemetryListener?.sendUIInteraction(
           "model-editor-hide-modeled-methods",
@@ -409,19 +391,8 @@ export class ModelEditorView extends AbstractWebview<
       if (!queryResult) {
         return;
       }
-      this.methods = queryResult;
 
-      await this.postMessage({
-        t: "setMethods",
-        methods: this.methods,
-      });
-      if (this.isMostRecentlyActiveView(this)) {
-        await this.updateMethodsUsagePanelState(
-          this.methods,
-          this.databaseItem,
-          this.hideModeledMethods,
-        );
-      }
+      this.modelingStore.setMethods(this.databaseItem, queryResult);
     } catch (err) {
       void showAndLogExceptionWithTelemetry(
         this.app.logger,
@@ -527,6 +498,7 @@ export class ModelEditorView extends AbstractWebview<
 
       const view = new ModelEditorView(
         this.app,
+        this.modelingStore,
         this.databaseManager,
         this.cliServer,
         this.queryRunner,
@@ -535,11 +507,7 @@ export class ModelEditorView extends AbstractWebview<
         addedDatabase,
         modelFile,
         Mode.Framework,
-        this.updateMethodsUsagePanelState,
         this.showMethod,
-        this.handleViewBecameActive,
-        this.handleViewWasDisposed,
-        this.isMostRecentlyActiveView,
       );
       await view.openView();
     });
@@ -617,4 +585,17 @@ export class ModelEditorView extends AbstractWebview<
 
     return addedDatabase;
   }
+
+  private registerToModelingStoreEvents() {
+    this.push(
+      this.modelingStore.onMethodsChanged(async (event) => {
+        if (event.dbUri === this.databaseItem.databaseUri.toString()) {
+          await this.postMessage({
+            t: "setMethods",
+            methods: event.methods,
+          });
+        }
+      }),
+    );
+  }
 }