#13274

Committed 04 Nov 2024 02:42PM UTC coverage: 89.088% (+0.9%) from 88.207%

Build Type

push

Committed by

Commit Message

Merge 99d15489d into d2d08a75d

Run Details

7343 of 8689 branches covered (84.51%)

Branch coverage included in aggregate %.

1105 of 1221 new or added lines in 28 files covered. (90.5%)

24 existing lines in 5 files now uncovered.

9688 of 10428 relevant lines covered (92.9%)

1797.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.21

/src/lsp/PathFilterer.ts

import * as micromatch from 'micromatch';
import * as path from 'path';
import type { Logger } from '../logging';
import { createLogger } from '../logging';
import util from '../util';

/**
 * Manage collections of glob patterns used to filter paths.
 *
 * excludeLists are evaluated first to see if a path should be excluded. If the path is excluded, we then test it against the includeLists.
 * If the path matches an includeList, it will be included. If not, it will remain excluded.
 */
export class PathFilterer {
    public constructor(
        options?: {
            logger?: Logger;
        }
    ) {
        this.logger = options?.logger ?? createLogger();
    }

    private logger: Logger;

    private includeCollections: PathCollection[] = [];

    private excludeCollections: PathCollection[] = [];

    /**
     * Filter the given list of entries based on the registered include and exclude lists.
     * @param entries the list of paths (or objects having paths) to filter
     * @param fetcher a function that can extract the path from the entry if it's not a string
     * @returns the filtered list of entries
     */
    public filter<T = string>(entries: T[], fetcher?: (path: T) => string) {
        //if there are no exclude lists, then all files should be included
        if (this.excludeCollections.length === 0) {
            return entries;
        }

        let results: T[] = [];

        //process each path
        for (let entry of entries) {
            let srcPath = fetcher?.(entry) ?? entry as unknown as string;

            //if this path is excluded
            if (this.isExclusionsMatch(srcPath)) {
                //if this path is re-included, keep it
                if (this.isInclusionsMatch(srcPath)) {
                    results.push(entry);
                } else {
                    //this path should be excluded
                }

                //this path is not excluded, so keep it
            } else {
                results.push(entry);
            }
        }
        return results;
    }

    /**
     * Does the path match at least one of the exclusions lists
     */
    private isExclusionsMatch(path: string) {
        //does this path match an exclusion list?
        for (const collection of this.excludeCollections) {
            if (collection.isMatch(path)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Does the path match at least one of the inclusions lists
     */
    private isInclusionsMatch(path: string) {
        //does this path match an exclusion list?
        for (const collection of this.includeCollections) {
            if (collection.isMatch(path)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Register a list of inclusive globs that should be evaluated together
     * These should be things like the `files` array from a bsconfig.json
     */
    public registerIncludeList(rootDir: string, globs: string[]) {
        this.logger.debug('registerIncludeList', { rootDir: rootDir, globs: globs });
        let collection = new PathCollection({
            rootDir: rootDir,
            globs: globs
        });
        this.includeCollections.push(collection);
        return () => {
            this.removeCollection(collection);
        };
    }

    /**
     * Register glob patterns for files that should be _excluded_. positive patterns mean a file is excluded,
     * and negative patterns mean a file that was previously matched (excluded) should be unmatched (included)
     * These should be things like .gitignore or vscode's `files.exclude`.
     *
     * @example
     * ```typescript
     * [
     *     '.git',
     *     'node_modules'
     *     '!node_modules/@rokucommunity/bslib'
     * ]
     * ```
     * would exclude all files in the `.git` and `node_modules` directories, but would include the `node_modules/@rokucommunity/bslib` directory
     */
    public registerExcludeList(rootDir: string, globs: string[]) {
        this.logger.debug('registerExcludeList', { rootDir: rootDir, globs: globs });
        let collection = new PathCollection({
            rootDir: rootDir,
            globs: globs
        });
        this.excludeCollections.push(collection);
        return () => {
            this.removeCollection(collection);
        };
    }

    public registerExcludeMatcher(matcher: (path: string) => boolean) {
        this.logger.debug('registerExcludeMatcher', matcher);

        const collection = new PathCollection({
            matcher: matcher,
            isExcludePattern: false
        });
        this.excludeCollections.push(collection);
        return () => {
            this.removeCollection(collection);
        };
    }

    private removeCollection(collection: PathCollection) {
        let idx = this.includeCollections.indexOf(collection);
        if (idx > -1) {
            this.includeCollections.splice(idx, 1);
        }
        idx = this.excludeCollections.indexOf(collection);
        if (idx > -1) {
            this.excludeCollections.splice(idx, 1);
        }
    }

    /**
     * Remove all registered collections
     */
    public clear() {
        this.includeCollections = [];
        this.excludeCollections = [];
    }
}

export class PathCollection {
    constructor(
        public options: {
            rootDir: string;
            globs: string[];
        } | {
            matcher: (path: string) => boolean;
            isExcludePattern: boolean;
        }
    ) {
        if ('globs' in options) {
            //build matcher patterns from the globs
            for (let glob of options.globs ?? []) {
                let isExcludePattern = glob.startsWith('!');
                if (isExcludePattern) {
                    glob = glob.substring(1);
                }
                const pattern = path.resolve(
                    options.rootDir,
                    glob
                ).replace(/\\+/g, '/');
                this.matchers.push({
                    pattern: pattern,
                    isMatch: micromatch.matcher(pattern),
                    isExcludePattern: isExcludePattern
                });
            }
        } else {
            this.matchers.push({
                isMatch: options.matcher,
                isExcludePattern: options.isExcludePattern
            });
        }
    }

    private matchers: Array<{
        pattern?: string;
        isMatch: (string) => boolean;
        isExcludePattern: boolean;
    }> = [];

    public isMatch(path: string) {
        let keep = false;
        //coerce the path into a normalized form and unix slashes
        path = util.standardizePath(path).replace(/\\+/g, '/');
        for (let matcher of this.matchers) {
            //exclusion pattern: do not keep the path if it matches
            if (matcher.isExcludePattern) {
                if (matcher.isMatch(path)) {
                    keep = false;
                }
                //inclusion pattern: keep the path if it matches
            } else {
                keep = keep || matcher.isMatch(path);
            }
        }
        return keep;
    }
}

1	import * as micromatch from 'micromatch';	1✔
2	import * as path from 'path';	1✔
3	import type { Logger } from '../logging';
4	import { createLogger } from '../logging';	1✔
5	import util from '../util';	1✔
6
7	/**
8	* Manage collections of glob patterns used to filter paths.
9	*
10	* excludeLists are evaluated first to see if a path should be excluded. If the path is excluded, we then test it against the includeLists.
11	* If the path matches an includeList, it will be included. If not, it will remain excluded.
12	*/
13	export class PathFilterer {	1✔
14	public constructor(
15	options?: {
16	logger?: Logger;
17	}
18	) {
19	this.logger = options?.logger ?? createLogger();	95✔
20	}
21
22	private logger: Logger;
23
24	private includeCollections: PathCollection[] = [];	95✔
25
26	private excludeCollections: PathCollection[] = [];	95✔
27
28	/**
29	* Filter the given list of entries based on the registered include and exclude lists.
30	* @param entries the list of paths (or objects having paths) to filter
31	* @param fetcher a function that can extract the path from the entry if it's not a string
32	* @returns the filtered list of entries
33	*/
34	public filter<T = string>(entries: T[], fetcher?: (path: T) => string) {
35	//if there are no exclude lists, then all files should be included
36	if (this.excludeCollections.length === 0) {	250✔
37	return entries;	207✔
38	}
39
40	let results: T[] = [];	43✔
41
42	//process each path
43	for (let entry of entries) {	43✔
44	let srcPath = fetcher?.(entry) ?? entry as unknown as string;	75✔
45
46	//if this path is excluded
47	if (this.isExclusionsMatch(srcPath)) {	75✔
48	//if this path is re-included, keep it
49	if (this.isInclusionsMatch(srcPath)) {	42✔
50	results.push(entry);	8✔
51	} else {
52	//this path should be excluded
53	}
54
55	//this path is not excluded, so keep it
56	} else {
57	results.push(entry);	33✔
58	}
59	}
60	return results;	43✔
61	}
62
63	/**
64	* Does the path match at least one of the exclusions lists
65	*/
66	private isExclusionsMatch(path: string) {
67	//does this path match an exclusion list?
68	for (const collection of this.excludeCollections) {	75✔
69	if (collection.isMatch(path)) {	114✔
70	return true;	42✔
71	}
72	}
73	return false;	33✔
74	}
75
76	/**
77	* Does the path match at least one of the inclusions lists
78	*/
79	private isInclusionsMatch(path: string) {
80	//does this path match an exclusion list?
81	for (const collection of this.includeCollections) {	42✔
82	if (collection.isMatch(path)) {	22✔
83	return true;	8✔
84	}
85	}
86	return false;	34✔
87	}
88
89	/**
90	* Register a list of inclusive globs that should be evaluated together
91	* These should be things like the `files` array from a bsconfig.json
92	*/
93	public registerIncludeList(rootDir: string, globs: string[]) {
94	this.logger.debug('registerIncludeList', { rootDir: rootDir, globs: globs });	76✔
95	let collection = new PathCollection({	76✔
96	rootDir: rootDir,
97	globs: globs
98	});
99	this.includeCollections.push(collection);	76✔
100	return () => {	76✔
101	this.removeCollection(collection);	73✔
102	};
103	}
104
105	/**
106	* Register glob patterns for files that should be _excluded_. positive patterns mean a file is excluded,
107	* and negative patterns mean a file that was previously matched (excluded) should be unmatched (included)
108	* These should be things like .gitignore or vscode's `files.exclude`.
109	*
110	* @example
111	* ```typescript
112	* [
113	* '.git',
114	* 'node_modules'
115	* '!node_modules/@rokucommunity/bslib'
116	* ]
117	* ```
118	* would exclude all files in the `.git` and `node_modules` directories, but would include the `node_modules/@rokucommunity/bslib` directory
119	*/
120	public registerExcludeList(rootDir: string, globs: string[]) {
121	this.logger.debug('registerExcludeList', { rootDir: rootDir, globs: globs });	42✔
122	let collection = new PathCollection({	42✔
123	rootDir: rootDir,
124	globs: globs
125	});
126	this.excludeCollections.push(collection);	42✔
127	return () => {	42✔
128	this.removeCollection(collection);	7✔
129	};
130	}
131
132	public registerExcludeMatcher(matcher: (path: string) => boolean) {
133	this.logger.debug('registerExcludeMatcher', matcher);	5✔
134
135	const collection = new PathCollection({	5✔
136	matcher: matcher,
137	isExcludePattern: false
138	});
139	this.excludeCollections.push(collection);	5✔
140	return () => {	5✔
NEW 141	this.removeCollection(collection);	×
142	};
143	}
144
145	private removeCollection(collection: PathCollection) {
146	let idx = this.includeCollections.indexOf(collection);	80✔
147	if (idx > -1) {	80✔
148	this.includeCollections.splice(idx, 1);	72✔
149	}
150	idx = this.excludeCollections.indexOf(collection);	80✔
151	if (idx > -1) {	80✔
152	this.excludeCollections.splice(idx, 1);	7✔
153	}
154	}
155
156	/**
157	* Remove all registered collections
158	*/
159	public clear() {
160	this.includeCollections = [];	2✔
161	this.excludeCollections = [];	2✔
162	}
163	}
164
165	export class PathCollection {	1✔
166	constructor(
167	public options: {	176✔
168	rootDir: string;
169	globs: string[];
170	} \| {
171	matcher: (path: string) => boolean;
172	isExcludePattern: boolean;
173	}
174	) {
175	if ('globs' in options) {	176✔
176	//build matcher patterns from the globs
177	for (let glob of options.globs ?? []) {	171✔
178	let isExcludePattern = glob.startsWith('!');	475✔
179	if (isExcludePattern) {	475✔
180	glob = glob.substring(1);	6✔
181	}
182	const pattern = path.resolve(	475✔
183	options.rootDir,
184	glob
185	).replace(/\\+/g, '/');
186	this.matchers.push({	475✔
187	pattern: pattern,
188	isMatch: micromatch.matcher(pattern),
189	isExcludePattern: isExcludePattern
190	});
191	}
192	} else {
193	this.matchers.push({	5✔
194	isMatch: options.matcher,
195	isExcludePattern: options.isExcludePattern
196	});
197	}
198	}
199
200	private matchers: Array<{	176✔
201	pattern?: string;
202	isMatch: (string) => boolean;
203	isExcludePattern: boolean;
204	}> = [];
205
206	public isMatch(path: string) {
207	let keep = false;	228✔
208	//coerce the path into a normalized form and unix slashes
209	path = util.standardizePath(path).replace(/\\+/g, '/');	228✔
210	for (let matcher of this.matchers) {	228✔
211	//exclusion pattern: do not keep the path if it matches
212	if (matcher.isExcludePattern) {	553✔
213	if (matcher.isMatch(path)) {	7!
214	keep = false;	7✔
215	}
216	//inclusion pattern: keep the path if it matches
217	} else {
218	keep = keep \|\| matcher.isMatch(path);	546✔
219	}
220	}
221	return keep;	228✔
222	}
223	}

rokucommunity / brighterscript / #13274

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous