Adds glob excludes for #2

eamodio · Oct 12, 2017 · c3702b4 · c3702b4
1 parent 1e0930e
commit c3702b4
Show file tree

Hide file tree

Showing 4 changed files with 84 additions and 21 deletions.
diff --git a/src/rule.ts b/src/rule.ts
@@ -1,6 +1,7 @@
 'use strict';
-import { CancellationToken, TextDocument, Uri, workspace } from 'vscode';
+import { TextDocument, Uri } from 'vscode';
 import { Logger } from './logger';
+import { RulesProvider } from './rulesProvider';
 // import * as glob from 'glob';
 
 const tokenReplacer = /(\$([0-9]))/g;
@@ -54,18 +55,14 @@ export class Rule implements IRule, IRuleDefinition {
             const globPattern = Rule.replaceTokens(locator, this._match);
             Logger.log(`Rule(${this.rulesetName}).provideRelated(${fileName}, ${rootPath})`, `globPattern=${globPattern}`);
             // yield Rule.globAsync(globPattern, { cwd: rootPath, nocase: true });
-            yield Rule.findFilesAsync(globPattern);
+            yield RulesProvider.findFiles(globPattern);
         }
     }
 
     private static replaceTokens(pattern: string, ruleMatch: RegExpExecArray): string {
         return pattern.replace(tokenReplacer, (match: string, p1: string, p2: string) => ruleMatch[+p2]);
     }
 
-    private static async findFilesAsync(pattern: string, maxResults?: number, token?: CancellationToken): Promise<Uri[]> {
-        return await workspace.findFiles(pattern, undefined, maxResults, token);
-    }
-
     // private static async globAsync(pattern: string, options?: glob.IOptions): Promise<Uri[]> {
     //     return new Promise<Uri[]>((resolve, reject) => {
     //         glob(pattern, options, (err: Error, matches: string[]) => {

diff --git a/src/rulesProvider.ts b/src/rulesProvider.ts
@@ -1,6 +1,6 @@
 'use strict';
-import { Arrays } from './system';
-import { Disposable, ExtensionContext, TextDocument, Uri, workspace } from 'vscode';
+import { Arrays, Objects } from './system';
+import { CancellationToken, Disposable, ExtensionContext, TextDocument, Uri, workspace } from 'vscode';
 import { ExtensionKey, IConfig } from './configuration';
 import { Logger } from './logger';
 import { IRule, IRuleDefinition, Rule } from './rule';
@@ -24,28 +24,30 @@ interface IRegisteredRuleset {
 
 export class RulesProvider extends Disposable {
 
+    private static _excludes: string | null | undefined;
+
     rules: IRule[];
     rulesets: IRuleset[];
 
-    private disposable: Disposable;
-
-    private registeredRulesets: IRegisteredRuleset[];
+    private _disposable: Disposable;
+    private _registeredRulesets: IRegisteredRuleset[];
 
     constructor(context: ExtensionContext) {
         super(() => this.dispose());
 
         this.rulesets = require(context.asAbsolutePath('./rulesets.json'));
 
         this.onConfigurationChanged();
-        this.disposable = workspace.onDidChangeConfiguration(this.onConfigurationChanged, this);
+        this._disposable = workspace.onDidChangeConfiguration(this.onConfigurationChanged, this);
     }
 
     dispose() {
-        this.disposable && this.disposable.dispose();
+        this._disposable && this._disposable.dispose();
     }
 
     private onConfigurationChanged(): void {
         this.compileRules();
+        RulesProvider._excludes = undefined;
     }
 
     provideRules(fileName: string): IRule[] {
@@ -59,22 +61,22 @@ export class RulesProvider extends Disposable {
     }
 
     registerRuleset(name: string, rules: (IDynamicRule | IRuleDefinition)[]): Disposable {
-        if (!this.registeredRulesets) {
-            this.registeredRulesets = [];
+        if (!this._registeredRulesets) {
+            this._registeredRulesets = [];
         }
 
         const ruleset = {
             name: name,
             rules: rules
         } as IRegisteredRuleset;
-        this.registeredRulesets.push(ruleset);
+        this._registeredRulesets.push(ruleset);
 
         this.compileRules();
 
         return {
             dispose: () => {
-                const index = this.registeredRulesets.indexOf(ruleset);
-                this.registeredRulesets.splice(index, 1);
+                const index = this._registeredRulesets.indexOf(ruleset);
+                this._registeredRulesets.splice(index, 1);
                 this.compileRules();
             }
         } as Disposable;
@@ -101,8 +103,8 @@ export class RulesProvider extends Disposable {
             }
         }
 
-        if (this.registeredRulesets && this.registeredRulesets.length) {
-            for (const ruleset of this.registeredRulesets) {
+        if (this._registeredRulesets && this._registeredRulesets.length) {
+            for (const ruleset of this._registeredRulesets) {
                 rules.push(...ruleset.rules.map(rule => {
                     if (typeof (rule as IDynamicRule).match === 'function' &&
                         typeof (rule as IDynamicRule).provideRelated === 'function') {
@@ -123,4 +125,48 @@ export class RulesProvider extends Disposable {
 
         this.rules = rules;
     }
+
+    static findFiles(pattern: string, maxResults?: number, token?: CancellationToken): Promise<Uri[]> {
+        return workspace.findFiles(pattern, RulesProvider._excludes || this.getFindFilesExcludes(), maxResults, token) as Promise<Uri[]>;
+    }
+
+    private static getFindFilesExcludes(): string| undefined {
+        if (RulesProvider._excludes === undefined) {
+            const fileExclude = workspace.getConfiguration('files').get<{ [key: string]: boolean } | undefined>('exclude', undefined);
+            const searchExclude = workspace.getConfiguration('search').get<{ [key: string]: boolean } | undefined>('exclude', undefined);
+
+            if (fileExclude !== undefined || searchExclude !== undefined) {
+                const excludes: { [key: string]: boolean } = Object.create(null);
+                if (fileExclude !== undefined) {
+                    for (const [key, value] of Objects.entries(fileExclude)) {
+                        if (!value) continue;
+
+                        excludes[key] = true;
+                    }
+                }
+
+                if (searchExclude !== undefined) {
+                    for (const [key, value] of Objects.entries(searchExclude)) {
+                        if (!value) continue;
+
+                        excludes[key] = true;
+                    }
+                }
+
+                const patterns = Object.keys(excludes);
+                RulesProvider._excludes = (patterns.length > 0) ?
+                    `{${patterns.join(',')}}`
+                    : null;
+            }
+            else {
+                RulesProvider._excludes = null;
+            }
+
+            Logger.log(`excludes=${RulesProvider._excludes}`);
+        }
+
+        return RulesProvider._excludes !== null
+            ? RulesProvider._excludes
+            : undefined;
+    }
 }
diff --git a/src/system.ts b/src/system.ts
@@ -1,2 +1,3 @@
 'use strict';
-export * from './system/array';
+export * from './system/array';
+export * from './system/object';
diff --git a/src/system/object.ts b/src/system/object.ts
@@ -0,0 +1,19 @@
+'use strict';
+
+export namespace Objects {
+    export function entries<T>(o: { [key: string]: T }): IterableIterator<[string, T]>;
+    export function entries<T>(o: { [key: number]: T }): IterableIterator<[string, T]>;
+    export function* entries<T>(o: any): IterableIterator<[string, T]> {
+        for (const key in o) {
+            yield [key, o[key]];
+        }
+    }
+
+    export function values<T>(o: { [key: string]: T }): IterableIterator<T>;
+    export function values<T>(o: { [key: number]: T }): IterableIterator<T>;
+    export function* values<T>(o: any): IterableIterator<T> {
+        for (const key in o) {
+            yield o[key];
+        }
+    }
+}