#12812

Committed 22 Jul 2024 03:48PM UTC coverage: 86.199% (+0.5%) from 85.672%

Build Type

push

Committed by

Commit Message

Merge 0cd26e472 into 0eae960e0

Run Details

10596 of 13083 branches covered (80.99%)

Branch coverage included in aggregate %.

82 of 88 new or added lines in 15 files covered. (93.18%)

69 existing lines in 5 files now uncovered.

12295 of 13473 relevant lines covered (91.26%)

26574.32 hits per line

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

97.76

/src/DiagnosticFilterer.ts

import type { BsDiagnostic } from './interfaces';
import * as path from 'path';
import * as minimatch from 'minimatch';
import type { BsConfig } from './BsConfig';
import util, { standardizePath as s } from './util';
import { URI } from 'vscode-uri';

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

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

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


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

    /**
     * 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 = {};
        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 = {};

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

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

        //if there's a src, match against all files
        if (filter.src) {
            //prepend rootDir to src if the filter is a relative path
            let src = s(
                path.isAbsolute(filter.src) ? filter.src : `${this.rootDir}/${filter.src}`
            );

            const byFileSrcs = Object.keys(this.byFile).map(uri => URI.parse(uri).fsPath);
            matchedFileUris = minimatch.match(byFileSrcs, src, {
                nocase: true
            }).map(src => util.pathToUri(src).toLowerCase());

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

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

    private filterFile(filter: NormalizedFilter, fileUri: 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;
        const lowerFileUri = fileUri.toLowerCase();
        //if there is no code, set isSuppressed on every diagnostic in this file
        if (!filter.codes) {
            this.byFile[lowerFileUri].forEach(diagnostic => {
                diagnostic.isSuppressed = isSuppressing;
            });

            //set isSuppressed for any diagnostics with matching codes
        } else {
            let fileDiagnostics = this.byFile[lowerFileUri];
            for (const diagnostic of fileDiagnostics) {
                if (filter.codes.includes(diagnostic.diagnostic.code!)) {
                    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') {
                result.push({
                    codes: [filter],
                    isNegative: false
                });
                continue;
            }

            if (typeof filter === 'string') {
                const isNegative = filter.startsWith('!');
                const trimmedFilter = isNegative ? filter.slice(1) : filter;

                result.push({
                    src: trimmedFilter,
                    isNegative: isNegative
                });
                continue;
            }

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

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

            if ('src' in filter) {
                const isNegative = filter.src.startsWith('!');
                const trimmedFilter = isNegative ? filter.src.slice(1) : filter.src;

                if ('codes' in filter) {
                    result.push({
                        src: trimmedFilter,
                        codes: filter.codes,
                        isNegative: isNegative
                    });
                } else {
                    result.push({
                        src: trimmedFilter,
                        isNegative: isNegative
                    });
                }
            }
        }
        return result;
    }
}

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 util, { standardizePath as s } from './util';	1✔
6	import { URI } from 'vscode-uri';	1✔
7
8	interface DiagnosticWithSuppression {
9	diagnostic: BsDiagnostic;
10	isSuppressed: boolean;
11	}
12
13	interface NormalizedFilter {
14	src?: string;
15	codes?: (number \| string)[];
16	isNegative: boolean;
17	}
18
19	export class DiagnosticFilterer {	1✔
20	private byFile: Record<string, DiagnosticWithSuppression[]>;
21	private filters: NormalizedFilter[] \| undefined;
22	private rootDir: string \| undefined;
23
24
25	constructor() {
26	this.byFile = {};	1,568✔
27	}
28
29	/**
30	* Filter a list of diagnostics based on the provided filters
31	*/
32	public filter(options: BsConfig, diagnostics: BsDiagnostic[]) {
33	this.filters = this.getDiagnosticFilters(options);	1,157✔
34	this.rootDir = options.rootDir;	1,157✔
35
36	this.groupByFile(diagnostics);	1,157✔
37
38	for (let filter of this.filters) {	1,157✔
39	this.filterAllFiles(filter);	68✔
40	}
41	let result = this.getDiagnostics();	1,157✔
42
43	//clean up
44	this.byFile = {};	1,157✔
45	delete this.rootDir;	1,157✔
46	delete this.filters;	1,157✔
47
48	return result;	1,157✔
49	}
50
51	/**
52	* Iterate over all remaining diagnostics from the byFile map.
53	* Also removes duplicates
54	*/
55	private getDiagnostics() {
56	//combine all remaining diagnostics
57	let finalDiagnostics = [] as BsDiagnostic[];	1,157✔
58	for (let key in this.byFile) {	1,157✔
59	let fileDiagnostics = this.byFile[key];	511✔
60	for (let diagnostic of fileDiagnostics) {	511✔
61	//filter out duplicate and suppressed diagnostics
62	if (!finalDiagnostics.includes(diagnostic.diagnostic) && !diagnostic.isSuppressed) {	659✔
63	finalDiagnostics.push(diagnostic.diagnostic);	638✔
64	}
65	}
66	}
67	return finalDiagnostics;	1,157✔
68	}
69
70	/**
71	* group the diagnostics by file
72	*/
73	private groupByFile(diagnostics: BsDiagnostic[]) {
74	this.byFile = {};	1,157✔
75
76	for (let diagnostic of diagnostics) {	1,157✔
77	const fileUri = diagnostic?.location?.uri ?? 'invalid-uri';	659!
78	//skip diagnostics that have issues
79	if (!fileUri) {	659!
UNCOV 80	continue;	×
81	}
82	const lowerFileUri = fileUri.toLowerCase();	659✔
83	//make a new array for this file if one does not yet exist
84	if (!this.byFile[lowerFileUri]) {	659✔
85	this.byFile[lowerFileUri] = [];	511✔
86	}
87	this.byFile[lowerFileUri].push({	659✔
88	diagnostic: diagnostic,
89	isSuppressed: false
90	});
91	}
92	}
93
94	private filterAllFiles(filter: NormalizedFilter) {
95	let matchedFileUris: string[];
96
97	//if there's a src, match against all files
98	if (filter.src) {	68✔
99	//prepend rootDir to src if the filter is a relative path
100	let src = s(	38✔
101	path.isAbsolute(filter.src) ? filter.src : `${this.rootDir}/${filter.src}`	38✔
102	);
103
104	const byFileSrcs = Object.keys(this.byFile).map(uri => URI.parse(uri).fsPath);	73✔
105	matchedFileUris = minimatch.match(byFileSrcs, src, {	38✔
106	nocase: true
107	}).map(src => util.pathToUri(src).toLowerCase());	23✔
108
109	//there is no src; this applies to all files
110	} else {
111	matchedFileUris = Object.keys(this.byFile);	30✔
112	}
113
114	//filter each matched file
115	for (let fileUri of matchedFileUris) {	68✔
116	this.filterFile(filter, fileUri);	67✔
117	}
118	}
119
120	private filterFile(filter: NormalizedFilter, fileUri: string) {
121	//if the filter is negative, we're turning diagnostics on
122	//if the filter is not negative we're turning diagnostics off
123	const isSuppressing = !filter.isNegative;	65✔
124	const lowerFileUri = fileUri.toLowerCase();	65✔
125	//if there is no code, set isSuppressed on every diagnostic in this file
126	if (!filter.codes) {	65✔
127	this.byFile[lowerFileUri].forEach(diagnostic => {	13✔
128	diagnostic.isSuppressed = isSuppressing;	22✔
129	});
130
131	//set isSuppressed for any diagnostics with matching codes
132	} else {
133	let fileDiagnostics = this.byFile[lowerFileUri];	52✔
134	for (const diagnostic of fileDiagnostics) {	52✔
135	if (filter.codes.includes(diagnostic.diagnostic.code!)) {	89✔
136	diagnostic.isSuppressed = isSuppressing;	25✔
137	}
138	}
139	}
140	}
141
142	public getDiagnosticFilters(config: BsConfig) {
143	let globalIgnoreCodes: (number \| string)[] = [...config.ignoreErrorCodes ?? []];	1,168✔
144	let diagnosticFilters = [...config.diagnosticFilters ?? []];	1,168✔
145
146	let result: NormalizedFilter[] = [];	1,168✔
147
148	//include a filter for all global ignore codes
149	//this comes first, because negative patterns will override ignoreErrorCodes
150	if (globalIgnoreCodes.length > 0) {	1,168✔
151	result.push({	5✔
152	codes: globalIgnoreCodes,
153	isNegative: false
154	});
155	}
156
157	for (let filter of diagnosticFilters) {	1,168✔
158	if (typeof filter === 'number') {	79✔
159	result.push({	15✔
160	codes: [filter],
161	isNegative: false
162	});
163	continue;	15✔
164	}
165
166	if (typeof filter === 'string') {	64✔
167	const isNegative = filter.startsWith('!');	2✔
168	const trimmedFilter = isNegative ? filter.slice(1) : filter;	2✔
169
170	result.push({	2✔
171	src: trimmedFilter,
172	isNegative: isNegative
173	});
174	continue;	2✔
175	}
176
177	//filter out bad inputs
178	if (!filter \|\| typeof filter !== 'object') {	62✔
179	continue;	4✔
180	}
181
182	//code-only filter
183	if ('codes' in filter && !('src' in filter) && Array.isArray(filter.codes)) {	58✔
184	result.push({	15✔
185	codes: filter.codes,
186	isNegative: false
187	});
188	continue;	15✔
189	}
190
191	if ('src' in filter) {	43✔
192	const isNegative = filter.src.startsWith('!');	42✔
193	const trimmedFilter = isNegative ? filter.src.slice(1) : filter.src;	42✔
194
195	if ('codes' in filter) {	42✔
196	result.push({	16✔
197	src: trimmedFilter,
198	codes: filter.codes,
199	isNegative: isNegative
200	});
201	} else {
202	result.push({	26✔
203	src: trimmedFilter,
204	isNegative: isNegative
205	});
206	}
207	}
208	}
209	return result;	1,168✔
210	}
211	}

rokucommunity / brighterscript / #12812

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