1. Build workspace.code-workspace settings file to filter out selected modules

2. Open workspace.code-workspace file on project import

Author: AlexeiShmidman

html/editor.html

@@ -15,7 +15,7 @@
             style="height: 1.5em;">Browse...</button>
     </div>
 
-<!--
+    <!--
     <div>
         <label for="targetLocation">Target folder</label>
         <input type="text" id="targetLocation" name="targetLocation" style="width: 50%; height: 1.5em;">
@@ -102,9 +102,11 @@
             const divNode = document.getElementById(moduleListDivId);
             const divModuleNodes = divNode.getElementsByTagName('input');
             for (i = 0; i < divModuleNodes.length; i++) {
+                const moduleName = divModuleNodes[i].value;
                 if (divModuleNodes[i].checked) {
-                    const moduleName = divModuleNodes[i].value;
-                    modules.push(moduleName);
+                    modules.push({ name: moduleName, selected: true });
+                } else {
+                    modules.push({ name: moduleName, selected: false });
                 }
             }
             vscode.postMessage({

src/bazelmodule.ts

@@ -1,16 +1,8 @@
 export class BazelModule {
-    private name: string;
-    private selected: boolean;
+    name: string;
+    selected: boolean;
     constructor(name: string, selected: boolean) {
         this.name = name;
         this.selected = selected;
     }
-
-    getModule(): string {
-        return this.name;
-    }
-
-    getSelected(): boolean {
-        return this.selected;
-    }
 }

src/bazelproject.ts

@@ -3,9 +3,12 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as bazelmodule from './bazelmodule';
 import * as projectparser from './bazelprojectparser';
-
+import * as vscodeworkspace from './workspace';
 
 export class BazelProject {
+    private readonly codeWorkspaceExt: string = '.code-workspace';
+    private readonly codeWorkspaceFile: string = 'workspace' + this.codeWorkspaceExt;
+
     sourceWorkspace: string;
     sourceFolder: string;
     targetFolder: string;
@@ -17,12 +20,14 @@ export class BazelProject {
 
     }
 
-    openProject(modules: string[]) {
-        this.buildBazelProject(modules);
+    openProject(modules: bazelmodule.BazelModule[]) {
         // this.makeTargetFolder();
+        // this.buildBazelProject(modules, this.targetFolder);
         // this.buildSymlinks(modules);
         // this.openFolder(this.targetFolder);
-        this.openFolder(this.sourceFolder);
+        this.buildBazelProject(modules, this.sourceFolder);
+        this.buildCodeWorkspace(modules, this.sourceFolder);
+        this.openFolder(path.join(this.sourceFolder, this.codeWorkspaceFile));
     }
 
     lookupModules(): bazelmodule.BazelModule[] {
@@ -47,14 +52,27 @@ export class BazelProject {
         return modules;
     }
 
-    private buildBazelProject(modules: string[]) {
-        const bazelprojectFile = path.join(this.sourceFolder, '.bazelproject');
+    private buildCodeWorkspace(modules: bazelmodule.BazelModule[], folder: string) {
+        const codeWorkspaceFile: vscodeworkspace.VsCodeWorkspace = new vscodeworkspace.VsCodeWorkspace(modules);
+        const vscodeWorkspace = path.join(folder, this.codeWorkspaceFile);
+        const content: string = JSON.stringify(codeWorkspaceFile, null, 2);
+
+        fs.writeFileSync(vscodeWorkspace, content);
+    }
+
+    private buildBazelProject(modules: bazelmodule.BazelModule[], folder: string) {
+        const bazelprojectFile = path.join(folder, '.bazelproject');
         if (modules && modules.length > 0) {
             if (fs.existsSync(bazelprojectFile)) {
                 fs.renameSync(bazelprojectFile, bazelprojectFile + '.' + Date.now());
             }
             let fileContent = 'directories:\n';
-            modules.forEach((moduleName) => { fileContent = fileContent + '  ' + moduleName + '\n'; });
+            modules.//
+                filter((module) => true === module.selected).//
+                forEach((module) => {
+                    const name: string = module.name;
+                    fileContent = fileContent + '  ' + name + '\n';
+                });
             fs.writeFileSync(bazelprojectFile, fileContent);
         } else if (fs.existsSync(bazelprojectFile)) {
             fs.unlinkSync(bazelprojectFile);
@@ -81,8 +99,8 @@ export class BazelProject {
                 const sourceModulePath = path.join(this.sourceFolder, moduleName);
                 fs.symlinkSync(sourceModulePath, targetModulePath);
             });
-            // const targetWorkspaceFile = path.join(this.targetFolder, 'WORKSPACE');
-            // fs.symlinkSync(this.sourceWorkspace, targetWorkspaceFile);
+            const targetWorkspaceFile = path.join(this.targetFolder, 'WORKSPACE');
+            fs.symlinkSync(this.sourceWorkspace, targetWorkspaceFile);
         }
     }
 }

src/editor.ts

@@ -8,7 +8,6 @@ import * as bazelmodule from './bazelmodule';
 export function handleMessages(extCtx: vscode.ExtensionContext, webPanel: vscode.WebviewPanel, message: any) {
     switch (message.command) {
         case 'importProject': {
-            console.log('importProject');
             const bi: bazelproject.BazelProject = new bazelproject.BazelProject(message.source, message.target);
             bi.openProject(message.modules);
             return;

src/workspace.ts

@@ -0,0 +1,32 @@
+import * as bazelmodule from './bazelmodule';
+
+export class VsCodeWorkspace {
+    private readonly filesExclude: string = 'files.exclude';
+    private readonly currentFolder: string = '.';
+
+    folders: VsCodePath[];
+    settings: any;
+    constructor(modules: bazelmodule.BazelModule[]) {
+        this.folders = [];
+        this.folders.push({ path: this.currentFolder });
+        this.settings = {};
+        this.settings[this.filesExclude] = this.buildExcludes(modules);
+    }
+
+    private buildExcludes(modules: bazelmodule.BazelModule[]): {} {
+        let exclude: any = {};
+        if (modules) {
+            modules.//
+                filter((module) => false === module.selected).//
+                forEach((module) => {
+                    exclude[module.name] = true;
+                });
+        }
+        return exclude;
+    }
+}
+
+class VsCodePath {
+    constructor(public path: string) {
+    }
+}