#12806

Committed 20 Jul 2024 12:26PM UTC coverage: 85.672%. Remained the same

Build Type

push

Committed by

Commit Message

Merge ede4b5a84 into 0eae960e0

Run Details

10889 of 13587 branches covered (80.14%)

Branch coverage included in aggregate %.

61 of 67 new or added lines in 7 files covered. (91.04%)

64 existing lines in 4 files now uncovered.

12316 of 13499 relevant lines covered (91.24%)

26532.02 hits per line

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

90.1

/src/DiagnosticFilterer.ts

import type { BsDiagnostic } from './interfaces';
import * as path from 'path';
import * as minimatch from 'minimatch';
import type { BsConfig } from './BsConfig';
import { standardizePath as s } from './util';

interface DiagnosticWithSuppression {
    diagnostic: BsDiagnostic;
    isSuppressed: boolean;
}

interface NormalizedFilter {
    src?: string;
    dest?: string;
    codes?: (number | string)[];
    isNegative: boolean;
}

export class DiagnosticFilterer {
    private byFile: Record<string, DiagnosticWithSuppression[]>;
    private fileDestSrcMap: Record<string, string>;
    private filters: NormalizedFilter[] | undefined;
    private rootDir: string | undefined;


    constructor() {
        this.byFile = {};
        this.fileDestSrcMap = {};
    }

    /**
     * Filter a list of diagnostics based on the provided filters
     */
    public filter(options: BsConfig, diagnostics: BsDiagnostic[]) {
        this.filters = this.getDiagnosticFilters(options);
        this.rootDir = options.rootDir;

        this.groupByFile(diagnostics);

        for (let filter of this.filters) {
            this.filterAllFiles(filter);
        }
        let result = this.getDiagnostics();

        //clean up
        this.byFile = {};
        this.fileDestSrcMap = {};
        delete this.rootDir;
        delete this.filters;

        return result;
    }

    /**
     * Iterate over all remaining diagnostics from the byFile map.
     * Also removes duplicates
     */
    private getDiagnostics() {
        //combine all remaining diagnostics
        let finalDiagnostics = [] as BsDiagnostic[];
        for (let key in this.byFile) {
            let fileDiagnostics = this.byFile[key];
            for (let diagnostic of fileDiagnostics) {
                //filter out duplicate and suppressed diagnostics
                if (!finalDiagnostics.includes(diagnostic.diagnostic) && !diagnostic.isSuppressed) {
                    finalDiagnostics.push(diagnostic.diagnostic);
                }
            }
        }
        return finalDiagnostics;
    }

    /**
     * group the diagnostics by file
     */
    private groupByFile(diagnostics: BsDiagnostic[]) {
        this.byFile = {};
        this.fileDestSrcMap = {};
        for (let diagnostic of diagnostics) {
            const srcPath = diagnostic?.file?.srcPath;

            //skip diagnostics that have issues
            if (!srcPath) {
                continue;
            }
            const lowerSrcPath = srcPath.toLowerCase();
            //make a new array for this file if one does not yet exist
            if (!this.byFile[lowerSrcPath]) {
                this.byFile[lowerSrcPath] = [];
            }
            this.byFile[lowerSrcPath].push({
                diagnostic: diagnostic,
                isSuppressed: false
            });
        }
        for (let diagnostic of diagnostics) {
            const destPath = diagnostic?.file?.destPath;
            const srcPath = diagnostic?.file?.srcPath;

            //skip diagnostics that have issues
            if (!destPath || !srcPath) {
                continue;
            }

            const lowerDestPath = destPath.toLowerCase();
            const lowerSrcPath = srcPath.toLowerCase();
            this.fileDestSrcMap[lowerDestPath] = lowerSrcPath;
        }
    }

    private filterAllFiles(filter: NormalizedFilter) {
        let matchedFilePaths: string[];

        if (filter.src) {
            //if there's a src, match against all files

            //prepend rootDir to src if the filter is a relative path
            let src = s(
                path.isAbsolute(filter.src) ? filter.src : `${this.rootDir}/${filter.src}`
            );

            matchedFilePaths = minimatch.match(Object.keys(this.byFile), src, {
                nocase: true
            });

        } else if (filter.dest) {
            // applies to file dest location

            //prepend rootDir to dest if the filter is a relative path
            let dest = s(
                path.isAbsolute(filter.dest) ? filter.dest : `${this.rootDir}/${filter.dest}`
            );
            // search against the set of file destinations
            const matchedDestFilePaths = minimatch.match(Object.keys(this.fileDestSrcMap), dest, {
                nocase: true
            });
            // convert to file srcs
            matchedFilePaths = matchedDestFilePaths.map(destPath => this.fileDestSrcMap[destPath]);

        } else {
            //there is no src; this applies to all files
            matchedFilePaths = Object.keys(this.byFile);
        }

        //filter each matched file
        for (let filePath of matchedFilePaths) {
            this.filterFile(filter, filePath);
        }
    }

    private filterFile(filter: NormalizedFilter, filePath: string) {
        //if the filter is negative, we're turning diagnostics on
        //if the filter is not negative we're turning diagnostics off
        const isSuppressing = !filter.isNegative;

        // get correct diagnostics set
        const fileDiagnostics = this.byFile[filePath];

        //if there is no code, set isSuppressed on every diagnostic in this file
        if (!filter.codes) {
            fileDiagnostics.forEach(diagnostic => {
                diagnostic.isSuppressed = isSuppressing;
            });

            //set isSuppressed for any diagnostics with matching codes
        } else {
            for (const diagnostic of fileDiagnostics) {
                if (filter.codes.includes(diagnostic.diagnostic.code!) ||
                    (diagnostic.diagnostic.legacyCode &&
                        (filter.codes.includes(diagnostic.diagnostic.legacyCode) ||
                            filter.codes.includes(diagnostic.diagnostic.legacyCode.toString())))) {
                    diagnostic.isSuppressed = isSuppressing;
                }
            }
        }
    }

    public getDiagnosticFilters(config: BsConfig) {
        let globalIgnoreCodes: (number | string)[] = [...config.ignoreErrorCodes ?? []];
        let diagnosticFilters = [...config.diagnosticFilters ?? []];

        let result: NormalizedFilter[] = [];

        //include a filter for all global ignore codes
        //this comes first, because negative patterns will override ignoreErrorCodes
        if (globalIgnoreCodes.length > 0) {
            result.push({
                codes: globalIgnoreCodes,
                isNegative: false
            });
        }

        for (let filter of diagnosticFilters) {
            if (typeof filter === 'number' || typeof filter === 'string') {
                result.push({
                    codes: [filter],
                    isNegative: false
                });
                continue;
            }

            //filter out bad inputs
            if (!filter || typeof filter !== 'object') {
                continue;
            }

            //code-only filter
            if ('codes' in filter && !('files' in filter) && Array.isArray(filter.codes)) {
                result.push({
                    codes: filter.codes,
                    isNegative: false
                });
                continue;
            }

            if ('files' in filter) {
                if (typeof filter.files === 'string') {
                    result.push(this.getNormalizedFilter(filter.files, filter));
                    continue;
                }

                if (Array.isArray(filter.files)) {
                    for (const fileIdentifier of filter.files) {
                        if (typeof fileIdentifier === 'string') {
                            result.push(this.getNormalizedFilter(fileIdentifier, filter));
                            continue;
                        }
                        if (typeof fileIdentifier === 'object') {
                            if ('src' in fileIdentifier) {
                                result.push(this.getNormalizedFilter(fileIdentifier.src, filter));
                                continue;
                            }
                            if ('dest' in fileIdentifier) {
                                result.push(this.getNormalizedFilter(fileIdentifier.dest, filter, 'dest'));
                                continue;
                            }
                        }
                    }
                }
            }
        }
        return result;
    }


    private getNormalizedFilter(fileGlob: string, filter: { files: string } | { codes?: (number | string)[] }, locationKey: 'src' | 'dest' = 'src'): NormalizedFilter {
        const isNegative = fileGlob.startsWith('!');
        const trimmedFilter = isNegative ? fileGlob.slice(1) : fileGlob;
        if (locationKey === 'src') {
            if ('codes' in filter && Array.isArray(filter.codes)) {
                return {
                    src: trimmedFilter,
                    codes: filter.codes,
                    isNegative: isNegative
                };
            } else {
                return {
                    src: trimmedFilter,
                    isNegative: isNegative
                };
            }
        } else {
            // dest
            if ('codes' in filter && Array.isArray(filter.codes)) {
                return {
                    dest: trimmedFilter,
                    codes: filter.codes,
                    isNegative: isNegative
                };
            } else {
                return {
                    dest: trimmedFilter,
                    isNegative: isNegative
                };
            }
        }

    }
}

1	import type { BsDiagnostic } from './interfaces';
2	import * as path from 'path';	1✔
3	import * as minimatch from 'minimatch';	1✔
4	import type { BsConfig } from './BsConfig';
5	import { standardizePath as s } from './util';	1✔
6
7	interface DiagnosticWithSuppression {
8	diagnostic: BsDiagnostic;
9	isSuppressed: boolean;
10	}
11
12	interface NormalizedFilter {
13	src?: string;
14	dest?: string;
15	codes?: (number \| string)[];
16	isNegative: boolean;
17	}
18
19	export class DiagnosticFilterer {	1✔
20	private byFile: Record<string, DiagnosticWithSuppression[]>;
21	private fileDestSrcMap: Record<string, string>;
22	private filters: NormalizedFilter[] \| undefined;
23	private rootDir: string \| undefined;
24
25
26	constructor() {
27	this.byFile = {};	1,569✔
28	this.fileDestSrcMap = {};	1,569✔
29	}
30
31	/**
32	* Filter a list of diagnostics based on the provided filters
33	*/
34	public filter(options: BsConfig, diagnostics: BsDiagnostic[]) {
35	this.filters = this.getDiagnosticFilters(options);	1,161✔
36	this.rootDir = options.rootDir;	1,161✔
37
38	this.groupByFile(diagnostics);	1,161✔
39
40	for (let filter of this.filters) {	1,161✔
41	this.filterAllFiles(filter);	86✔
42	}
43	let result = this.getDiagnostics();	1,161✔
44
45	//clean up
46	this.byFile = {};	1,161✔
47	this.fileDestSrcMap = {};	1,161✔
48	delete this.rootDir;	1,161✔
49	delete this.filters;	1,161✔
50
51	return result;	1,161✔
52	}
53
54	/**
55	* Iterate over all remaining diagnostics from the byFile map.
56	* Also removes duplicates
57	*/
58	private getDiagnostics() {
59	//combine all remaining diagnostics
60	let finalDiagnostics = [] as BsDiagnostic[];	1,161✔
61	for (let key in this.byFile) {	1,161✔
62	let fileDiagnostics = this.byFile[key];	518✔
63	for (let diagnostic of fileDiagnostics) {	518✔
64	//filter out duplicate and suppressed diagnostics
65	if (!finalDiagnostics.includes(diagnostic.diagnostic) && !diagnostic.isSuppressed) {	666✔
66	finalDiagnostics.push(diagnostic.diagnostic);	642✔
67	}
68	}
69	}
70	return finalDiagnostics;	1,161✔
71	}
72
73	/**
74	* group the diagnostics by file
75	*/
76	private groupByFile(diagnostics: BsDiagnostic[]) {
77	this.byFile = {};	1,161✔
78	this.fileDestSrcMap = {};	1,161✔
79	for (let diagnostic of diagnostics) {	1,161✔
80	const srcPath = diagnostic?.file?.srcPath;	666!
81
82	//skip diagnostics that have issues
83	if (!srcPath) {	666!
UNCOV 84	continue;	×
85	}
86	const lowerSrcPath = srcPath.toLowerCase();	666✔
87	//make a new array for this file if one does not yet exist
88	if (!this.byFile[lowerSrcPath]) {	666✔
89	this.byFile[lowerSrcPath] = [];	518✔
90	}
91	this.byFile[lowerSrcPath].push({	666✔
92	diagnostic: diagnostic,
93	isSuppressed: false
94	});
95	}
96	for (let diagnostic of diagnostics) {	1,161✔
97	const destPath = diagnostic?.file?.destPath;	666!
98	const srcPath = diagnostic?.file?.srcPath;	666!
99
100	//skip diagnostics that have issues
101	if (!destPath \|\| !srcPath) {	666✔
102	continue;	2✔
103	}
104
105	const lowerDestPath = destPath.toLowerCase();	664✔
106	const lowerSrcPath = srcPath.toLowerCase();	664✔
107	this.fileDestSrcMap[lowerDestPath] = lowerSrcPath;	664✔
108	}
109	}
110
111	private filterAllFiles(filter: NormalizedFilter) {
112	let matchedFilePaths: string[];
113
114	if (filter.src) {	86✔
115	//if there's a src, match against all files
116
117	//prepend rootDir to src if the filter is a relative path
118	let src = s(	42✔
119	path.isAbsolute(filter.src) ? filter.src : `${this.rootDir}/${filter.src}`	42✔
120	);
121
122	matchedFilePaths = minimatch.match(Object.keys(this.byFile), src, {	42✔
123	nocase: true
124	});
125
126	} else if (filter.dest) {	44✔
127	// applies to file dest location
128
129	//prepend rootDir to dest if the filter is a relative path
130	let dest = s(	2✔
131	path.isAbsolute(filter.dest) ? filter.dest : `${this.rootDir}/${filter.dest}`	2!
132	);
133	// search against the set of file destinations
134	const matchedDestFilePaths = minimatch.match(Object.keys(this.fileDestSrcMap), dest, {	2✔
135	nocase: true
136	});
137	// convert to file srcs
138	matchedFilePaths = matchedDestFilePaths.map(destPath => this.fileDestSrcMap[destPath]);	5✔
139
140	} else {
141	//there is no src; this applies to all files
142	matchedFilePaths = Object.keys(this.byFile);	42✔
143	}
144
145	//filter each matched file
146	for (let filePath of matchedFilePaths) {	86✔
147	this.filterFile(filter, filePath);	99✔
148	}
149	}
150
151	private filterFile(filter: NormalizedFilter, filePath: string) {
152	//if the filter is negative, we're turning diagnostics on
153	//if the filter is not negative we're turning diagnostics off
154	const isSuppressing = !filter.isNegative;	95✔
155
156	// get correct diagnostics set
157	const fileDiagnostics = this.byFile[filePath];	95✔
158
159	//if there is no code, set isSuppressed on every diagnostic in this file
160	if (!filter.codes) {	95✔
161	fileDiagnostics.forEach(diagnostic => {	13✔
162	diagnostic.isSuppressed = isSuppressing;	22✔
163	});
164
165	//set isSuppressed for any diagnostics with matching codes
166	} else {
167	for (const diagnostic of fileDiagnostics) {	82✔
168	if (filter.codes.includes(diagnostic.diagnostic.code!) \|\|	130✔
169	(diagnostic.diagnostic.legacyCode &&
170	(filter.codes.includes(diagnostic.diagnostic.legacyCode) \|\|
171	filter.codes.includes(diagnostic.diagnostic.legacyCode.toString())))) {
172	diagnostic.isSuppressed = isSuppressing;	34✔
173	}
174	}
175	}
176	}
177
178	public getDiagnosticFilters(config: BsConfig) {
179	let globalIgnoreCodes: (number \| string)[] = [...config.ignoreErrorCodes ?? []];	1,171✔
180	let diagnosticFilters = [...config.diagnosticFilters ?? []];	1,171✔
181
182	let result: NormalizedFilter[] = [];	1,171✔
183
184	//include a filter for all global ignore codes
185	//this comes first, because negative patterns will override ignoreErrorCodes
186	if (globalIgnoreCodes.length > 0) {	1,171✔
187	result.push({	5✔
188	codes: globalIgnoreCodes,
189	isNegative: false
190	});
191	}
192
193	for (let filter of diagnosticFilters) {	1,171✔
194	if (typeof filter === 'number' \|\| typeof filter === 'string') {	96✔
195	result.push({	27✔
196	codes: [filter],
197	isNegative: false
198	});
199	continue;	27✔
200	}
201
202	//filter out bad inputs
203	if (!filter \|\| typeof filter !== 'object') {	69✔
204	continue;	4✔
205	}
206
207	//code-only filter
208	if ('codes' in filter && !('files' in filter) && Array.isArray(filter.codes)) {	65✔
209	result.push({	16✔
210	codes: filter.codes,
211	isNegative: false
212	});
213	continue;	16✔
214	}
215
216	if ('files' in filter) {	49✔
217	if (typeof filter.files === 'string') {	48✔
218	result.push(this.getNormalizedFilter(filter.files, filter));	46✔
219	continue;	46✔
220	}
221
222	if (Array.isArray(filter.files)) {	2!
223	for (const fileIdentifier of filter.files) {	2✔
224	if (typeof fileIdentifier === 'string') {	2!
NEW 225	result.push(this.getNormalizedFilter(fileIdentifier, filter));	×
NEW 226	continue;	×
227	}
228	if (typeof fileIdentifier === 'object') {	2!
229	if ('src' in fileIdentifier) {	2!
NEW 230	result.push(this.getNormalizedFilter(fileIdentifier.src, filter));	×
NEW 231	continue;	×
232	}
233	if ('dest' in fileIdentifier) {	2!
234	result.push(this.getNormalizedFilter(fileIdentifier.dest, filter, 'dest'));	2✔
235	continue;	2✔
236	}
237	}
238	}
239	}
240	}
241	}
242	return result;	1,171✔
243	}
244
245
246	private getNormalizedFilter(fileGlob: string, filter: { files: string } \| { codes?: (number \| string)[] }, locationKey: 'src' \| 'dest' = 'src'): NormalizedFilter {	46✔
247	const isNegative = fileGlob.startsWith('!');	48✔
248	const trimmedFilter = isNegative ? fileGlob.slice(1) : fileGlob;	48✔
249	if (locationKey === 'src') {	48✔
250	if ('codes' in filter && Array.isArray(filter.codes)) {	46✔
251	return {	18✔
252	src: trimmedFilter,
253	codes: filter.codes,
254	isNegative: isNegative
255	};
256	} else {
257	return {	28✔
258	src: trimmedFilter,
259	isNegative: isNegative
260	};
261	}
262	} else {
263	// dest
264	if ('codes' in filter && Array.isArray(filter.codes)) {	2!
265	return {	2✔
266	dest: trimmedFilter,
267	codes: filter.codes,
268	isNegative: isNegative
269	};
270	} else {
NEW 271	return {	×
272	dest: trimmedFilter,
273	isNegative: isNegative
274	};
275	}
276	}
277
278	}
279	}

rokucommunity / brighterscript / #12806

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