1228 multi root workspace symbols

.gitignore

@@ -2,9 +2,7 @@
 out
 node_modules
 *.pyc
-.vscode/.ropeproject/**
-src/test/.vscode/**
-**/.vscode/tags
+**/.vscode/.ropeproject/**
 **/testFiles/**/.cache/**
 *.noseids
 .vscode-test

package.json

@@ -1593,7 +1593,7 @@
     "vscode:prepublish": "tsc -p ./ && webpack",
     "compile": "webpack && tsc -watch -p ./",
     "postinstall": "node ./node_modules/vscode/bin/install",
-    "test": "node ./node_modules/vscode/bin/test && node ./out/test/multiRootTest.js",
+    "test": "node ./out/test/standardTest.js && node ./out/test/multiRootTest.js",
     "precommit": "node gulpfile.js",
     "lint": "tslint src/**/*.ts -t verbose"
   },

src/client/workspaceSymbols/generator.ts

@@ -2,17 +2,22 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as child_process from 'child_process';
-import { PythonSettings } from '../common/configSettings';
-
-const pythonSettings = PythonSettings.getInstance();
+import { IPythonSettings, PythonSettings } from '../common/configSettings';
 
 export class Generator implements vscode.Disposable {
     private optionsFile: string;
     private disposables: vscode.Disposable[];
-
-    constructor(private output: vscode.OutputChannel) {
+    private pythonSettings: IPythonSettings;
+    public get tagFilePath(): string {
+        return this.pythonSettings.workspaceSymbols.tagFilePath;
+    }
+    public get enabled(): boolean {
+        return this.pythonSettings.workspaceSymbols.enabled;
+    }
+    constructor(public readonly workspaceFolder: vscode.Uri, private output: vscode.OutputChannel) {
         this.disposables = [];
         this.optionsFile = path.join(__dirname, '..', '..', '..', 'resources', 'ctagOptions');
+        this.pythonSettings = PythonSettings.getInstance(workspaceFolder);
     }
 
     dispose() {
@@ -21,20 +26,25 @@ export class Generator implements vscode.Disposable {
 
     private buildCmdArgs(): string[] {
         const optionsFile = this.optionsFile.indexOf(' ') > 0 ? `"${this.optionsFile}"` : this.optionsFile;
-        const exclusions = pythonSettings.workspaceSymbols.exclusionPatterns;
+        const exclusions = this.pythonSettings.workspaceSymbols.exclusionPatterns;
         const excludes = exclusions.length === 0 ? [] : exclusions.map(pattern => `--exclude=${pattern}`);
 
         return [`--options=${optionsFile}`, '--languages=Python'].concat(excludes);
     }
 
-    generateWorkspaceTags(): Promise<any> {
-        const tagFile = path.normalize(pythonSettings.workspaceSymbols.tagFilePath);
-        return this.generateTags(tagFile, { directory: vscode.workspace.rootPath });
+    async generateWorkspaceTags(): Promise<void> {
+        if (!this.pythonSettings.workspaceSymbols.enabled) {
+            return;
+        }
+        return await this.generateTags({ directory: this.workspaceFolder.fsPath });
     }
 
-    private generateTags(outputFile: string, source: { directory?: string, file?: string }): Promise<any> {
-        const cmd = pythonSettings.workspaceSymbols.ctagsPath;
+    private generateTags(source: { directory?: string, file?: string }): Promise<void> {
+        const tagFile = path.normalize(this.pythonSettings.workspaceSymbols.tagFilePath);
+        const cmd = this.pythonSettings.workspaceSymbols.ctagsPath;
         const args = this.buildCmdArgs();
+
+        let outputFile = tagFile;
         if (source.file && source.file.length > 0) {
             source.directory = path.dirname(source.file);
         }
@@ -43,14 +53,14 @@ export class Generator implements vscode.Disposable {
             outputFile = path.basename(outputFile);
         }
         const outputDir = path.dirname(outputFile);
-        if (!fs.existsSync(outputDir)){
+        if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir);
         }
         outputFile = outputFile.indexOf(' ') > 0 ? `"${outputFile}"` : outputFile;
         args.push(`-o ${outputFile}`, '.');
         this.output.appendLine('-'.repeat(10) + 'Generating Tags' + '-'.repeat(10));
         this.output.appendLine(`${cmd} ${args.join(' ')}`);
-        const promise = new Promise<any>((resolve, reject) => {
+        const promise = new Promise<void>((resolve, reject) => {
             let options: child_process.SpawnOptions = {
                 cwd: source.directory
             };
@@ -75,7 +85,7 @@ export class Generator implements vscode.Disposable {
                     reject(errorMsg);
                 }
                 else {
-                    resolve(outputFile);
+                    resolve();
                 }
             });
         });

src/client/workspaceSymbols/main.ts

@@ -1,30 +1,39 @@
 import * as vscode from 'vscode';
 import { Generator } from './generator';
 import { Installer, InstallerResponse, Product } from '../common/installer';
-import { PythonSettings } from '../common/configSettings';
 import { fsExistsAsync } from '../common/utils';
 import { isNotInstalledError } from '../common/helpers';
 import { PythonLanguage, Commands } from '../common/constants';
 import { WorkspaceSymbolProvider } from './provider';
 
-const pythonSettings = PythonSettings.getInstance();
+const MAX_NUMBER_OF_ATTEMPTS_TO_INSTALL_AND_BUILD = 2;
 
 export class WorkspaceSymbols implements vscode.Disposable {
     private disposables: vscode.Disposable[];
-    private generator: Generator;
+    private generators: Generator[] = [];
     private installer: Installer;
     constructor(private outputChannel: vscode.OutputChannel) {
         this.disposables = [];
         this.disposables.push(this.outputChannel);
-        this.generator = new Generator(this.outputChannel);
-        this.disposables.push(this.generator);
         this.installer = new Installer();
         this.disposables.push(this.installer);
         this.registerCommands();
-
-        // The extension has just loaded, so lets rebuild the tags
-        vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(this.generator, this.outputChannel));
+        this.initializeGenerators();
+        vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(this.generators, this.outputChannel));
         this.buildWorkspaceSymbols(true);
+        this.disposables.push(vscode.workspace.onDidChangeWorkspaceFolders(() => this.initializeGenerators()));
+    }
+    private initializeGenerators() {
+        while (this.generators.length > 0) {
+            const generator = this.generators.shift();
+            generator.dispose();
+        }
+
+        if (Array.isArray(vscode.workspace.workspaceFolders)) {
+            vscode.workspace.workspaceFolders.forEach(wkSpc => {
+                this.generators.push(new Generator(wkSpc.uri, this.outputChannel));
+            });
+        }
     }
     registerCommands() {
         this.disposables.push(vscode.commands.registerCommand(Commands.Build_Workspace_Symbols, (rebuild: boolean = true, token?: vscode.CancellationToken) => {
@@ -52,40 +61,53 @@ export class WorkspaceSymbols implements vscode.Disposable {
     dispose() {
         this.disposables.forEach(d => d.dispose());
     }
-    buildWorkspaceSymbols(rebuild: boolean = true, token?: vscode.CancellationToken): Promise<any> {
-        if (!pythonSettings.workspaceSymbols.enabled || (token && token.isCancellationRequested)) {
+    async buildWorkspaceSymbols(rebuild: boolean = true, token?: vscode.CancellationToken): Promise<any> {
+        if (token && token.isCancellationRequested) {
             return Promise.resolve([]);
         }
-        if (!vscode.workspace || typeof vscode.workspace.rootPath !== 'string' || vscode.workspace.rootPath.length === 0) {
+        if (this.generators.length === 0) {
             return Promise.resolve([]);
         }
-        return fsExistsAsync(pythonSettings.workspaceSymbols.tagFilePath).then(exits => {
-            let promise = Promise.resolve();
 
+        let promptPromise: Promise<InstallerResponse>;
+        let promptResponse: InstallerResponse;
+        return this.generators.map(async generator => {
+            if (!generator.enabled) {
+                return;
+            }
+            const exists = await fsExistsAsync(generator.tagFilePath);
             // if file doesn't exist, then run the ctag generator
             // Or check if required to rebuild
-            if (rebuild || !exits) {
-                promise = this.generator.generateWorkspaceTags();
+            if (!rebuild && exists) {
+                return;
             }
-
-            return promise.catch(reason => {
-                if (!isNotInstalledError(reason)) {
-                    this.outputChannel.show();
-                    return Promise.reject(reason);
+            for (let counter = 0; counter < MAX_NUMBER_OF_ATTEMPTS_TO_INSTALL_AND_BUILD; counter++) {
+                try {
+                    await generator.generateWorkspaceTags();
+                    return;
+                }
+                catch (error) {
+                    if (!isNotInstalledError(error)) {
+                        this.outputChannel.show();
+                        return;
+                    }
                 }
                 if (!token || token.isCancellationRequested) {
                     return;
                 }
-                return this.installer.promptToInstall(Product.ctags)
-                    .then(result => {
-                        if (!token || token.isCancellationRequested) {
-                            return;
-                        }
-                        if (result === InstallerResponse.Installed) {
-                            return this.buildWorkspaceSymbols(rebuild, token);
-                        }
-                    });
-            });
+                // Display prompt once for all workspaces
+                if (promptPromise) {
+                    promptResponse = await promptPromise;
+                    continue;
+                }
+                else {
+                    promptPromise = this.installer.promptToInstall(Product.ctags);
+                    promptResponse = await promptPromise;
+                }
+                if (promptResponse !== InstallerResponse.Installed || (!token || token.isCancellationRequested)) {
+                    return;
+                }
+            }
         });
     }
 }

src/client/workspaceSymbols/parser.ts

@@ -1,14 +1,12 @@
 import * as vscode from 'vscode';
 import { Tag } from './contracts';
 import * as path from 'path';
-import { PythonSettings } from '../common/configSettings';
 import { fsExistsAsync } from '../common/utils';
 
 const LineByLineReader = require("line-by-line");
 const NamedRegexp = require('named-js-regexp');
 const fuzzy = require('fuzzy');
 
-const pythonSettings = PythonSettings.getInstance();
 const IsFileRegEx = /\tkind:file\tline:\d+$/g;
 const LINE_REGEX = '(?<name>\\w+)\\t(?<file>.*)\\t\\/\\^(?<code>.*)\\$\\/;"\\tkind:(?<type>\\w+)\\tline:(?<line>\\d+)$';
 
@@ -102,15 +100,14 @@ Object.keys(newValuesAndKeys).forEach(key => {
     CTagKinMapping.set(key, newValuesAndKeys[key]);
 });
 
-export function parseTags(query: string, token: vscode.CancellationToken, maxItems: number = 200): Promise<Tag[]> {
-    const file = pythonSettings.workspaceSymbols.tagFilePath;
-    return fsExistsAsync(file).then(exists => {
+export function parseTags(workspaceFolder: string, tagFile: string, query: string, token: vscode.CancellationToken, maxItems: number = 200): Promise<Tag[]> {
+    return fsExistsAsync(tagFile).then(exists => {
         if (!exists) {
             return null;
         }
 
         return new Promise<Tag[]>((resolve, reject) => {
-            let lr = new LineByLineReader(file);
+            let lr = new LineByLineReader(tagFile);
             let lineNumber = 0;
             let tags: Tag[] = [];
 
@@ -124,7 +121,7 @@ export function parseTags(query: string, token: vscode.CancellationToken, maxIte
                     lr.close();
                     return;
                 }
-                const tag = parseTagsLine(line, query);
+                const tag = parseTagsLine(workspaceFolder, line, query);
                 if (tag) {
                     tags.push(tag);
                 }
@@ -139,7 +136,7 @@ export function parseTags(query: string, token: vscode.CancellationToken, maxIte
         });
     });
 }
-function parseTagsLine(line: string, searchPattern: string): Tag {
+function parseTagsLine(workspaceFolder: string, line: string, searchPattern: string): Tag {
     if (IsFileRegEx.test(line)) {
         return;
     }
@@ -152,7 +149,7 @@ function parseTagsLine(line: string, searchPattern: string): Tag {
     }
     let file = match.file;
     if (!path.isAbsolute(file)) {
-        file = path.resolve(vscode.workspace.rootPath, '.vscode', file);
+        file = path.resolve(workspaceFolder, '.vscode', file);
     }
 
     const symbolKind = CTagKinMapping.has(match.type) ? CTagKinMapping.get(match.type) : vscode.SymbolKind.Null;

src/client/workspaceSymbols/provider.ts

@@ -1,36 +1,43 @@
 import * as vscode from 'vscode';
+import * as _ from 'lodash';
 import { Generator } from './generator';
-import { PythonSettings } from '../common/configSettings';
 import { parseTags } from './parser';
 import { fsExistsAsync } from '../common/utils';
-import { createDeferred } from '../common/helpers';
 import { Commands } from '../common/constants';
-const pythonSettings = PythonSettings.getInstance();
 
 export class WorkspaceSymbolProvider implements vscode.WorkspaceSymbolProvider {
-    public constructor(private tagGenerator: Generator, private outputChannel: vscode.OutputChannel) {
+    public constructor(private tagGenerators: Generator[], private outputChannel: vscode.OutputChannel) {
     }
 
     async provideWorkspaceSymbols(query: string, token: vscode.CancellationToken): Promise<vscode.SymbolInformation[]> {
-        if (!pythonSettings.workspaceSymbols.enabled) {
+        if (this.tagGenerators.length === 0) {
             return [];
         }
-        if (!vscode.workspace || typeof vscode.workspace.rootPath !== 'string' || vscode.workspace.rootPath.length === 0) {
-            return Promise.resolve([]);
-        }
-        // check whether tag file needs to be built
-        const tagFileExists = await fsExistsAsync(pythonSettings.workspaceSymbols.tagFilePath);
-        if (!tagFileExists) {
+        const generatorsWithTagFiles = await Promise.all(this.tagGenerators.map(generator => fsExistsAsync(generator.tagFilePath)));
+        if (generatorsWithTagFiles.filter(exists => exists).length !== this.tagGenerators.length) {
             await vscode.commands.executeCommand(Commands.Build_Workspace_Symbols, true, token);
         }
-        // load tags
-        const items = await parseTags(query, token);
-        if (!Array.isArray(items)) {
-            return [];
-        }
-        return items.map(item => new vscode.SymbolInformation(
-            item.symbolName, item.symbolKind, '',
-            new vscode.Location(vscode.Uri.file(item.fileName), item.position)
-        ));
+
+        const generators = await Promise.all(this.tagGenerators.map(async generator => {
+            const tagFileExists = await fsExistsAsync(generator.tagFilePath);
+            return tagFileExists ? generator : undefined;
+        }));
+
+        const promises = generators
+            .filter(generator => generator !== undefined && generator.enabled)
+            .map(async generator => {
+                // load tags
+                const items = await parseTags(generator.workspaceFolder.fsPath, generator.tagFilePath, query, token);
+                if (!Array.isArray(items)) {
+                    return [];
+                }
+                return items.map(item => new vscode.SymbolInformation(
+                    item.symbolName, item.symbolKind, '',
+                    new vscode.Location(vscode.Uri.file(item.fileName), item.position)
+                ));
+            });
+
+        const symbols = await Promise.all(promises);
+        return _.flatten(symbols);
     }
 }

src/test/.vscode/settings.json

@@ -0,0 +1,12 @@
+{
+    "python.pythonPath": "python",
+    "python.linting.pylintEnabled": true,
+    "python.linting.flake8Enabled": true,
+    "python.workspaceSymbols.enabled": true,
+    "python.unitTest.nosetestArgs": [],
+    "python.unitTest.pyTestArgs": [],
+    "python.unitTest.unittestArgs": [
+        "-s=./tests",
+        "-p=test_*.py"
+    ]
+}