Merge branch 'koesie10/filter-export-copy' into koesie10/selected-copy

Author: koesie10

extensions/ql-vscode/package.json

@@ -325,7 +325,7 @@
         "title": "CodeQL: Run Variant Analysis"
       },
       {
-        "command": "codeQL.exportVariantAnalysisResults",
+        "command": "codeQL.exportSelectedVariantAnalysisResults",
         "title": "CodeQL: Export Variant Analysis Results"
       },
       {
@@ -954,7 +954,7 @@
           "when": "config.codeQL.canary && config.codeQL.variantAnalysis.liveResults"
         },
         {
-          "command": "codeQL.exportVariantAnalysisResults",
+          "command": "codeQL.exportSelectedVariantAnalysisResults",
           "when": "config.codeQL.canary"
         },
         {

extensions/ql-vscode/src/common/app.ts

@@ -1,8 +1,17 @@
+import { Disposable } from '../pure/disposable-object';
 import { AppEventEmitter } from './events';
 
 export interface App {
   createEventEmitter<T>(): AppEventEmitter<T>;
+  mode: AppMode;
+  subscriptions: Disposable[];
   extensionPath: string;
   globalStoragePath: string;
   workspaceStoragePath?: string;
 }
+
+export enum AppMode {
+  Production = 1,
+  Development = 2,
+  Test = 3,
+}

extensions/ql-vscode/src/common/vscode/vscode-app.ts

@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
-import { App } from '../app';
+import { Disposable } from '../../pure/disposable-object';
+import { App, AppMode } from '../app';
 import { AppEventEmitter } from '../events';
 import { VSCodeAppEventEmitter } from './events';
 
@@ -21,6 +22,21 @@ export class ExtensionApp implements App {
     return this.extensionContext.storageUri?.fsPath;
   }
 
+  public get subscriptions(): Disposable[] {
+    return this.extensionContext.subscriptions;
+  }
+
+  public get mode(): AppMode {
+    switch (this.extensionContext.extensionMode) {
+      case vscode.ExtensionMode.Development:
+        return AppMode.Development;
+      case vscode.ExtensionMode.Test:
+        return AppMode.Test;
+      default:
+        return AppMode.Production;
+    }
+  }
+
   public createEventEmitter<T>(): AppEventEmitter<T> {
     return new VSCodeAppEventEmitter<T>();
   }

extensions/ql-vscode/src/databases/db-config-store.ts

@@ -6,8 +6,12 @@ import { DisposableObject } from '../pure/disposable-object';
 import { DbConfigValidator } from './db-config-validator';
 import { ValueResult } from '../common/value-result';
 import { App } from '../common/app';
+import { AppEvent, AppEventEmitter } from '../common/events';
 
 export class DbConfigStore extends DisposableObject {
+  public readonly onDidChangeConfig: AppEvent<void>;
+  private readonly onDidChangeConfigEventEmitter: AppEventEmitter<void>;
+
   private readonly configPath: string;
   private readonly configValidator: DbConfigValidator;
 
@@ -25,6 +29,8 @@ export class DbConfigStore extends DisposableObject {
     this.configErrors = [];
     this.configWatcher = undefined;
     this.configValidator = new DbConfigValidator(app.extensionPath);
+    this.onDidChangeConfigEventEmitter = app.createEventEmitter<void>();
+    this.onDidChangeConfig = this.onDidChangeConfigEventEmitter.event;
   }
 
   public async initialize(): Promise<void> {
@@ -85,6 +91,8 @@ export class DbConfigStore extends DisposableObject {
     }
 
     this.config = this.configErrors.length === 0 ? newConfig : undefined;
+
+    this.onDidChangeConfigEventEmitter.fire();
   }
 
   private watchConfig(): void {
@@ -95,15 +103,17 @@ export class DbConfigStore extends DisposableObject {
 
   private createEmptyConfig(): DbConfig {
     return {
-      remote: {
-        repositoryLists: [],
-        owners: [],
-        repositories: [],
-      },
-      local: {
-        lists: [],
-        databases: [],
-      },
+      databases: {
+        remote: {
+          repositoryLists: [],
+          owners: [],
+          repositories: [],
+        },
+        local: {
+          lists: [],
+          databases: [],
+        },
+      }
     };
   }
 }

extensions/ql-vscode/src/databases/db-config.ts

@@ -1,10 +1,25 @@
 // Contains models for the data we want to store in the database config
 
 export interface DbConfig {
+  databases: DbConfigDatabases;
+  selected?: SelectedDbItem;
+}
+
+export interface DbConfigDatabases {
   remote: RemoteDbConfig;
   local: LocalDbConfig;
 }
 
+export interface SelectedDbItem {
+  kind: SelectedDbItemKind;
+  value: string;
+}
+
+export enum SelectedDbItemKind {
+  ConfigDefined = 'configDefined',
+  RemoteSystemDefinedList = 'remoteSystemDefinedList',
+}
+
 export interface RemoteDbConfig {
   repositoryLists: RemoteRepositoryList[];
   owners: string[];
@@ -35,20 +50,26 @@ export interface LocalDatabase {
 
 export function cloneDbConfig(config: DbConfig): DbConfig {
   return {
-    remote: {
-      repositoryLists: config.remote.repositoryLists.map((list) => ({
-        name: list.name,
-        repositories: [...list.repositories],
-      })),
-      owners: [...config.remote.owners],
-      repositories: [...config.remote.repositories],
-    },
-    local: {
-      lists: config.local.lists.map((list) => ({
-        name: list.name,
-        databases: list.databases.map((db) => ({ ...db })),
-      })),
-      databases: config.local.databases.map((db) => ({ ...db })),
+    databases: {
+      remote: {
+        repositoryLists: config.databases.remote.repositoryLists.map((list) => ({
+          name: list.name,
+          repositories: [...list.repositories],
+        })),
+        owners: [...config.databases.remote.owners],
+        repositories: [...config.databases.remote.repositories],
+      },
+      local: {
+        lists: config.databases.local.lists.map((list) => ({
+          name: list.name,
+          databases: list.databases.map((db) => ({ ...db })),
+        })),
+        databases: config.databases.local.databases.map((db) => ({ ...db })),
+      },
     },
+    selected: config.selected ? {
+      kind: config.selected.kind,
+      value: config.selected.value,
+    } : undefined
   };
 }

extensions/ql-vscode/src/databases/db-manager.ts

@@ -1,12 +1,24 @@
+import { App } from '../common/app';
+import { AppEvent, AppEventEmitter } from '../common/events';
 import { ValueResult } from '../common/value-result';
 import { DbConfigStore } from './db-config-store';
 import { DbItem } from './db-item';
 import { createLocalTree, createRemoteTree } from './db-tree-creator';
 
 export class DbManager {
+  public readonly onDbItemsChanged: AppEvent<void>;
+  private readonly onDbItemsChangesEventEmitter: AppEventEmitter<void>;
+
   constructor(
+    app: App,
     private readonly dbConfigStore: DbConfigStore
   ) {
+    this.onDbItemsChangesEventEmitter = app.createEventEmitter<void>();
+    this.onDbItemsChanged = this.onDbItemsChangesEventEmitter.event;
+
+    this.dbConfigStore.onDidChangeConfig(() => {
+      this.onDbItemsChangesEventEmitter.fire();
+    });
   }
 
   public getDbItems(): ValueResult<DbItem[]> {

extensions/ql-vscode/src/databases/db-module.ts

@@ -1,5 +1,4 @@
-import * as vscode from 'vscode';
-import { ExtensionApp } from '../common/vscode/vscode-app';
+import { App, AppMode } from '../common/app';
 import { isCanary, isNewQueryRunExperienceEnabled } from '../config';
 import { logger } from '../logging';
 import { DisposableObject } from '../pure/disposable-object';
@@ -8,10 +7,8 @@ import { DbManager } from './db-manager';
 import { DbPanel } from './ui/db-panel';
 
 export class DbModule extends DisposableObject {
-  public async initialize(
-    extensionContext: vscode.ExtensionContext
-  ): Promise<void> {
-    if (extensionContext.extensionMode !== vscode.ExtensionMode.Development ||
+  public async initialize(app: App): Promise<void> {
+    if (app.mode !== AppMode.Development ||
       !isCanary() ||
       !isNewQueryRunExperienceEnabled()) {
       // Currently, we only want to expose the new database panel when we
@@ -22,25 +19,20 @@ export class DbModule extends DisposableObject {
 
     void logger.log('Initializing database module');
 
-    const app = new ExtensionApp(extensionContext);
-
     const dbConfigStore = new DbConfigStore(app);
     await dbConfigStore.initialize();
 
-    const dbManager = new DbManager(dbConfigStore);
+    const dbManager = new DbManager(app, dbConfigStore);
     const dbPanel = new DbPanel(dbManager);
     await dbPanel.initialize();
-    extensionContext.subscriptions.push(dbPanel);
 
     this.push(dbPanel);
     this.push(dbConfigStore);
   }
 }
 
-export async function initializeDbModule(
-  extensionContext: vscode.ExtensionContext
-): Promise<DbModule> {
+export async function initializeDbModule(app: App): Promise<DbModule> {
   const dbModule = new DbModule();
-  await dbModule.initialize(extensionContext);
+  await dbModule.initialize(app);
   return dbModule;
 }

extensions/ql-vscode/src/databases/db-tree-creator.ts

@@ -16,9 +16,9 @@ export function createRemoteTree(dbConfig: DbConfig): RootRemoteDbItem {
     createSystemDefinedList(1000)
   ];
 
-  const userDefinedRepoLists = dbConfig.remote.repositoryLists.map(createUserDefinedList);
-  const owners = dbConfig.remote.owners.map(createOwnerItem);
-  const repos = dbConfig.remote.repositories.map(createRepoItem);
+  const userDefinedRepoLists = dbConfig.databases.remote.repositoryLists.map(createUserDefinedList);
+  const owners = dbConfig.databases.remote.owners.map(createOwnerItem);
+  const repos = dbConfig.databases.remote.repositories.map(createRepoItem);
 
   return {
     kind: DbItemKind.RootRemote,

extensions/ql-vscode/src/databases/ui/db-tree-data-provider.ts

@@ -1,15 +1,29 @@
-import { ProviderResult, TreeDataProvider, TreeItem } from 'vscode';
+import { Event, EventEmitter, ProviderResult, TreeDataProvider, TreeItem } from 'vscode';
 import { createDbTreeViewItemError, DbTreeViewItem } from './db-tree-view-item';
 import { DbManager } from '../db-manager';
 import { mapDbItemToTreeViewItem } from './db-item-mapper';
+import { DisposableObject } from '../../pure/disposable-object';
 
-export class DbTreeDataProvider implements TreeDataProvider<DbTreeViewItem> {
+export class DbTreeDataProvider extends DisposableObject implements TreeDataProvider<DbTreeViewItem> {
+
+  // This is an event to signal that there's been a change in the tree which
+  // will case the view to refresh. It is part of the TreeDataProvider interface.
+  public readonly onDidChangeTreeData: Event<DbTreeViewItem | undefined>;
+
+  private _onDidChangeTreeData = this.push(new EventEmitter<DbTreeViewItem | undefined>());
   private dbTreeItems: DbTreeViewItem[];
 
   public constructor(
     private readonly dbManager: DbManager
   ) {
+    super();
     this.dbTreeItems = this.createTree();
+    this.onDidChangeTreeData = this._onDidChangeTreeData.event;
+
+    dbManager.onDbItemsChanged(() => {
+      this.dbTreeItems = this.createTree();
+      this._onDidChangeTreeData.fire(undefined);
+    });
   }
 
   /**

extensions/ql-vscode/src/extension.ts

@@ -98,7 +98,11 @@ import { RemoteQueryResult } from './remote-queries/remote-query-result';
 import { URLSearchParams } from 'url';
 import { handleDownloadPacks, handleInstallPackDependencies } from './packaging';
 import { HistoryItemLabelProvider } from './history-item-label-provider';
-import { exportRemoteQueryResults } from './remote-queries/export-results';
+import {
+  exportRemoteQueryResults,
+  exportSelectedRemoteQueryResults,
+  exportVariantAnalysisResults
+} from './remote-queries/export-results';
 import { RemoteQuery } from './remote-queries/remote-query';
 import { EvalLogViewer } from './eval-log-viewer';
 import { SummaryLanguageSupport } from './log-insights/summary-language-support';
@@ -116,6 +120,7 @@ import { createVariantAnalysisContentProvider } from './remote-queries/variant-a
 import { VSCodeMockGitHubApiServer } from './mocks/vscode-mock-gh-api-server';
 import { VariantAnalysisResultsManager } from './remote-queries/variant-analysis-results-manager';
 import { initializeDbModule } from './databases/db-module';
+import { ExtensionApp } from './common/vscode/vscode-app';
 import { RepositoriesFilterSortStateWithIds } from './pure/variant-analysis-filter-sort';
 
 /**
@@ -992,11 +997,23 @@ async function activateWithInstalledDistribution(
     }));
 
   ctx.subscriptions.push(
-    commandRunner('codeQL.exportVariantAnalysisResults', async (queryId?: string) => {
+    commandRunner('codeQL.exportSelectedVariantAnalysisResults', async () => {
+      await exportSelectedRemoteQueryResults(qhm);
+    })
+  );
+
+  ctx.subscriptions.push(
+    commandRunner('codeQL.exportRemoteQueryResults', async (queryId: string) => {
       await exportRemoteQueryResults(qhm, rqm, ctx, queryId);
     })
   );
 
+  ctx.subscriptions.push(
+    commandRunner('codeQL.exportVariantAnalysisResults', async (variantAnalysisId: number) => {
+      await exportVariantAnalysisResults(ctx, variantAnalysisManager, variantAnalysisId);
+    })
+  );
+
   ctx.subscriptions.push(
     commandRunner('codeQL.loadVariantAnalysisRepoResults', async (variantAnalysisId: number, repositoryFullName: string) => {
       await variantAnalysisManager.loadResults(variantAnalysisId, repositoryFullName);
@@ -1251,7 +1268,8 @@ async function activateWithInstalledDistribution(
   void logger.log('Reading query history');
   await qhm.readQueryHistory();
 
-  const dbModule = await initializeDbModule(ctx);
+  const app = new ExtensionApp(ctx);
+  const dbModule = await initializeDbModule(app);
   ctx.subscriptions.push(dbModule);
 
   void logger.log('Successfully finished extension initialization.');