11455074436

Committed 22 Oct 2024 07:10AM UTC coverage: 78.844% (-0.08%) from 78.922%

Build # 11455074436

Build Type

Pull #367

github

Committed by

web-flow

Commit Message

Merge 9fd682f8d into 0e61d30f7

Pull Request Pull Request #367: fix: Resolve properly namespaces with `lintFile()`

Run Details

1564 of 2117 branches covered (73.88%)

Branch coverage included in aggregate %.

14 of 14 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

2379 of 2884 relevant lines covered (82.49%)

1624.74 hits per line

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

92.97

/src/linter/linter.ts

import {graphFromObject} from "@ui5/project/graph";
import {createReader, createWorkspace, createReaderCollection, createFilterReader} from "@ui5/fs/resourceFactory";
import {FilePath, FilePattern, LinterOptions, FSToVirtualPathOptions, LintResult} from "./LinterContext.js";
import lintWorkspace from "./lintWorkspace.js";
import {taskStart} from "../utils/perf.js";
import path from "node:path";
import posixPath from "node:path/posix";
import {stat} from "node:fs/promises";
import {ProjectGraph} from "@ui5/project";
import type {AbstractReader, Resource} from "@ui5/fs";
import ConfigManager, {UI5LintConfigType} from "../utils/ConfigManager.js";
import {Minimatch} from "minimatch";

// Internal analytical variable that will store matchers' count.
// We cannot predict the outcome of the matchers, so stash usage statistics
// and later analyze the results from it.
const matchedPatterns = new Set<string>();

export async function lintProject({
        rootDir, filePatterns, ignorePattern, reportCoverage, includeMessageDetails, configPath, ui5ConfigPath,
}: LinterOptions): Promise<LintResult[]> {
        const configMngr = new ConfigManager(rootDir, configPath);
        const config = await configMngr.getConfiguration();

        // In case path is set both by CLI and config use CLI
        ui5ConfigPath = ui5ConfigPath ?? config.ui5Config;

        const projectGraphDone = taskStart("Project Graph creation");
        const graph = await getProjectGraph(rootDir, ui5ConfigPath);
        const project = graph.getRoot();
        projectGraphDone();

        let virBasePath = "/resources/";
        if (!project._isSourceNamespaced) {
                // Ensure the virtual filesystem includes the project namespace to allow relative imports
                // of framework resources from the project
                virBasePath += project.getNamespace() + "/";
        }
        const fsBasePath = project.getSourcePath();
        let reader = createReader({
                fsBasePath,
                virBasePath,
        });
        let virBasePathTest: string | undefined;
        let fsBasePathTest: string | undefined;
        if (project._testPathExists) {
                fsBasePathTest = path.join(project.getRootPath(), project._testPath);
                virBasePathTest = "/test-resources/";
                if (!project._isSourceNamespaced) {
                        // Dynamically add namespace if the physical project structure does not include it
                        // This logic is identical to the specification implementation in ui5-project
                        virBasePathTest += project.getNamespace() + "/";
                }
                reader = createReaderCollection({
                        readers: [reader, createReader({
                                fsBasePath: fsBasePathTest,
                                virBasePath: virBasePathTest,
                        })],
                });
        }

        const relFsBasePath = path.relative(rootDir, fsBasePath);
        const relFsBasePathTest = fsBasePathTest ? path.relative(rootDir, fsBasePathTest) : undefined;

        const res = await lint(reader, {
                rootDir,
                namespace: project.getNamespace(),
                filePatterns,
                ignorePattern,
                reportCoverage,
                includeMessageDetails,
                configPath,
                relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
        }, config);

        res.forEach((result) => {
                result.filePath = transformVirtualPathToFilePath(result.filePath,
                        relFsBasePath, virBasePath,
                        relFsBasePathTest, virBasePathTest);
        });
        // Sort by filePath after the virtual path has been converted back to ensure deterministic and sorted output.
        // Differences in order can happen as different linters (e.g. xml, json, html, ui5.yaml) are executed in parallel.
        sortLintResults(res);
        return res;
}

export async function lintFile({
        rootDir, filePatterns, ignorePattern, namespace, reportCoverage, includeMessageDetails, configPath,
}: LinterOptions): Promise<LintResult[]> {
        const configMngr = new ConfigManager(rootDir, configPath);
        const config = await configMngr.getConfiguration();

        const virBasePath = namespace ? `/resources/${namespace}/` : "/";
        const reader = createReader({
                fsBasePath: rootDir,
                virBasePath,
        });

        const res = await lint(reader, {
                rootDir,
                namespace,
                filePatterns,
                ignorePattern,
                reportCoverage,
                includeMessageDetails,
                configPath,
                relFsBasePath: "",
                virBasePath,
        }, config);

        res.forEach((result) => {
                result.filePath = transformVirtualPathToFilePath(result.filePath, "", "/");
        });
        // Sort by filePath after the virtual path has been converted back to ensure deterministic and sorted output.
        // Differences in order can happen as different linters (e.g. xml, json, html, ui5.yaml) are executed in parallel.
        sortLintResults(res);
        return res;
}

async function lint(
        resourceReader: AbstractReader, options: LinterOptions & FSToVirtualPathOptions,
        config: UI5LintConfigType
): Promise<LintResult[]> {
        const lintEnd = taskStart("Linting");
        let {ignorePattern, filePatterns} = options;
        const {relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest} = options;

        // Resolve files to include
        filePatterns = filePatterns ?? config.files ?? [];

        // Resolve ignores
        ignorePattern = [
                ...(config.ignores ?? []),
                ...(ignorePattern ?? []), // CLI patterns go after config patterns
        ].filter(($) => $);
        // Apply ignores to the workspace reader.
        // TypeScript needs the full context to provide correct analysis.
        // so, we can do filtering later via the filePathsReader
        const reader = resolveReader({
                patterns: ignorePattern,
                resourceReader,
                patternsMatch: matchedPatterns,
                relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
        });

        // Apply files + ignores over the filePaths reader
        let filePathsReader = resolveReader({
                patterns: filePatterns,
                resourceReader,
                inverseResult: true,
                patternsMatch: matchedPatterns,
                relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
        });
        filePathsReader = resolveReader({
                patterns: ignorePattern,
                resourceReader: filePathsReader,
                patternsMatch: matchedPatterns,
                relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
        });
        const filePathsWorkspace = createWorkspace({reader: filePathsReader});

        const workspace = createWorkspace({
                reader,
        });

        const res = await lintWorkspace(workspace, filePathsWorkspace, options, config, matchedPatterns);
        checkUnmatchedPatterns(filePatterns, matchedPatterns);

        lintEnd();
        return res;
}

async function getProjectGraph(rootDir: string, ui5ConfigPath?: string): Promise<ProjectGraph> {
        let rootConfigPath, rootConfiguration;
        const ui5YamlPath = ui5ConfigPath ? path.join(rootDir, ui5ConfigPath) : path.join(rootDir, "ui5.yaml");
        if (await fileExists(ui5YamlPath)) {
                rootConfigPath = ui5YamlPath;
        } else {
                if (ui5ConfigPath) throw new Error(`Unable to find UI5 config file '${ui5ConfigPath}'`);
                const isApp = await dirExists(path.join(rootDir, "webapp"));
                if (isApp) {
                        rootConfiguration = {
                                specVersion: "3.0",
                                type: "application",
                                metadata: {
                                        name: "ui5-linter-target",
                                },
                        };
                } else {
                        const isLibrary = await dirExists(path.join(rootDir, "src"));
                        if (isLibrary) {
                                rootConfiguration = {
                                        specVersion: "3.0",
                                        type: "library",
                                        metadata: {
                                                name: "ui5-linter-target",
                                        },
                                };
                        }
                }
        }

        if (!rootConfigPath && !rootConfiguration) {
                throw new Error(
                        `Unable to find a UI5 project at ${rootDir}. \n` +
                        `Please make sure to run "ui5lint" in the root directory of your UI5 project.`
                );
        }

        return graphFromObject({
                dependencyTree: {
                        id: "ui5-linter-target",
                        version: "1.0.0",
                        path: rootDir,
                        dependencies: [],
                },
                rootConfigPath,
                rootConfiguration,
                resolveFrameworkDependencies: false,
        });
}

/**
 * Normalize provided virtual paths to the original file paths
 */
function transformVirtualPathToFilePath(
        virtualPath: string,
        srcFsBasePath: string, srcVirBasePath: string,
        testFsBasePath?: string, testVirBasePath?: string
): FilePath {
        if (virtualPath.startsWith(srcVirBasePath)) {
                return path.join(srcFsBasePath, posixPath.relative(srcVirBasePath, virtualPath));
        } else if (testFsBasePath && testVirBasePath && virtualPath.startsWith(testVirBasePath)) {
                return path.join(testFsBasePath, posixPath.relative(testVirBasePath, virtualPath));
        } else if (virtualPath.startsWith("/")) {
                return posixPath.relative("/", virtualPath);
        } else {
                throw new Error(
                        `Resource path ${virtualPath} is not located within the virtual source or test directories of the project`);
        }
}

async function fsStat(fsPath: string) {
        try {
                return await stat(fsPath);
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
        } catch (err: any) {
                // "File or directory does not exist"
                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
                if (err.code === "ENOENT") {
                        return false;
                } else {
                        throw err;
                }
        }
}

async function dirExists(dirPath: string) {
        const stats = await fsStat(dirPath);
        return stats && stats.isDirectory();
}

async function fileExists(dirPath: string) {
        const stats = await fsStat(dirPath);
        return stats && stats.isFile();
}

function sortLintResults(lintResults: LintResult[]) {
        lintResults.sort((a, b) => a.filePath.localeCompare(b.filePath));
}

function isFileIncluded(file: string, patterns: Minimatch[], patternsMatch: Set<string>) {
        let include = true;

        for (const pattern of patterns) {
                if (pattern.negate && pattern.match(file)) {
                        patternsMatch.add(pattern.pattern);
                        include = true; // re-include it
                } else if (pattern.match(file)) { // Handle inclusion: exclude if it matches
                        patternsMatch.add(pattern.pattern);
                        include = false;
                }
        }

        return include;
}

function buildPatterns(patterns: string[]) {
        // Patterns must be only relative (to project's root),
        // otherwise throw an error
        return patterns.map((pattern) => {
                let notNegatedPattern = pattern;
                if (pattern.startsWith("!")) {
                        notNegatedPattern = pattern.slice(1);
                }

                if (path.isAbsolute(notNegatedPattern)) {
                        throw Error(`Pattern must be relative to project's root folder. ` +
                                `"${pattern}" defines an absolute path.`);
                }

                if (pattern.endsWith("/")) { // Match all files in a directory
                        pattern += "**/*";
                }

                return new Minimatch(pattern, {flipNegate: true});
        });
}

export function resolveReader({
        patterns,
        resourceReader,
        inverseResult = false,
        patternsMatch,
        relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
}: {
        patterns: string[];
        resourceReader: AbstractReader;
        inverseResult?: boolean;
        patternsMatch: Set<string>;
        relFsBasePath: string; virBasePath: string; relFsBasePathTest?: string; virBasePathTest?: string;
}) {
        if (!patterns.length) {
                return resourceReader;
        }

        const minimatchPatterns = buildPatterns(patterns);

        return createFilterReader({
                reader: resourceReader,
                callback: (resource: Resource) => {
                        // Minimatch works with FS and relative paths.
                        // So, we need to convert virtual paths to fs
                        const resPath = transformVirtualPathToFilePath(
                                resource.getPath(), relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest);

                        return inverseResult ?
                                        // When we work with files paths we actually need to limit the result to those
                                        // matches, instead of allowing all except XYZ
                                        !isFileIncluded(resPath, minimatchPatterns, patternsMatch) :
                                isFileIncluded(resPath, minimatchPatterns, patternsMatch);
                },
        });
}

/**
 * Checks which patterns were not matched during analysis
 *
 * @param patterns Available patterns
 * @throws Error if an unmatched pattern is found
 */
function checkUnmatchedPatterns(patterns: FilePattern[], patternsMatch: Set<string>) {
        const unmatchedPatterns = patterns.reduce((acc, pattern) => {
                if (pattern.endsWith("/")) { // Match all files in a directory
                        pattern += "**/*";
                }
                if (!patternsMatch.has(pattern)) {
                        acc.push(pattern);
                }

                return acc;
        }, [] as FilePattern[]);

        if (unmatchedPatterns.length) {
                throw new Error(`Specified file ${unmatchedPatterns.length === 1 ? "pattern" : "patterns"}` +
                        ` '${unmatchedPatterns.join("', '")}' did not match any resource`);
        }
}

1	import {graphFromObject} from "@ui5/project/graph";
2	import {createReader, createWorkspace, createReaderCollection, createFilterReader} from "@ui5/fs/resourceFactory";
3	import {FilePath, FilePattern, LinterOptions, FSToVirtualPathOptions, LintResult} from "./LinterContext.js";
4	import lintWorkspace from "./lintWorkspace.js";
5	import {taskStart} from "../utils/perf.js";
6	import path from "node:path";
7	import posixPath from "node:path/posix";
8	import {stat} from "node:fs/promises";
9	import {ProjectGraph} from "@ui5/project";
10	import type {AbstractReader, Resource} from "@ui5/fs";
11	import ConfigManager, {UI5LintConfigType} from "../utils/ConfigManager.js";
12	import {Minimatch} from "minimatch";
13
14	// Internal analytical variable that will store matchers' count.
15	// We cannot predict the outcome of the matchers, so stash usage statistics
16	// and later analyze the results from it.
17	const matchedPatterns = new Set<string>();	16✔
18
19	export async function lintProject({
20	rootDir, filePatterns, ignorePattern, reportCoverage, includeMessageDetails, configPath, ui5ConfigPath,
21	}: LinterOptions): Promise<LintResult[]> {
22	const configMngr = new ConfigManager(rootDir, configPath);	16✔
23	const config = await configMngr.getConfiguration();	16✔
24
25	// In case path is set both by CLI and config use CLI
26	ui5ConfigPath = ui5ConfigPath ?? config.ui5Config;	16✔
27
28	const projectGraphDone = taskStart("Project Graph creation");	16✔
29	const graph = await getProjectGraph(rootDir, ui5ConfigPath);	16✔
30	const project = graph.getRoot();	15✔
31	projectGraphDone();	15✔
32
33	let virBasePath = "/resources/";	15✔
34	if (!project._isSourceNamespaced) {	15✔
35	// Ensure the virtual filesystem includes the project namespace to allow relative imports
36	// of framework resources from the project
37	virBasePath += project.getNamespace() + "/";	12✔
38	}
39	const fsBasePath = project.getSourcePath();	15✔
40	let reader = createReader({	15✔
41	fsBasePath,
42	virBasePath,
43	});
44	let virBasePathTest: string \| undefined;
45	let fsBasePathTest: string \| undefined;
46	if (project._testPathExists) {	15✔
47	fsBasePathTest = path.join(project.getRootPath(), project._testPath);	4✔
48	virBasePathTest = "/test-resources/";	4✔
49	if (!project._isSourceNamespaced) {	4✔
50	// Dynamically add namespace if the physical project structure does not include it
51	// This logic is identical to the specification implementation in ui5-project
52	virBasePathTest += project.getNamespace() + "/";	2✔
53	}
54	reader = createReaderCollection({	4✔
55	readers: [reader, createReader({
56	fsBasePath: fsBasePathTest,
57	virBasePath: virBasePathTest,
58	})],
59	});
60	}
61
62	const relFsBasePath = path.relative(rootDir, fsBasePath);	15✔
63	const relFsBasePathTest = fsBasePathTest ? path.relative(rootDir, fsBasePathTest) : undefined;	15✔
64
65	const res = await lint(reader, {	15✔
66	rootDir,
67	namespace: project.getNamespace(),
68	filePatterns,
69	ignorePattern,
70	reportCoverage,
71	includeMessageDetails,
72	configPath,
73	relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
74	}, config);
75
76	res.forEach((result) => {	14✔
77	result.filePath = transformVirtualPathToFilePath(result.filePath,	107✔
78	relFsBasePath, virBasePath,
79	relFsBasePathTest, virBasePathTest);
80	});
81	// Sort by filePath after the virtual path has been converted back to ensure deterministic and sorted output.
82	// Differences in order can happen as different linters (e.g. xml, json, html, ui5.yaml) are executed in parallel.
83	sortLintResults(res);	14✔
84	return res;	14✔
85	}
86
87	export async function lintFile({
88	rootDir, filePatterns, ignorePattern, namespace, reportCoverage, includeMessageDetails, configPath,
89	}: LinterOptions): Promise<LintResult[]> {
90	const configMngr = new ConfigManager(rootDir, configPath);	72✔
91	const config = await configMngr.getConfiguration();	72✔
92
93	const virBasePath = namespace ? `/resources/${namespace}/` : "/";	72✔
94	const reader = createReader({	72✔
95	fsBasePath: rootDir,
96	virBasePath,
97	});
98
99	const res = await lint(reader, {	72✔
100	rootDir,
101	namespace,
102	filePatterns,
103	ignorePattern,
104	reportCoverage,
105	includeMessageDetails,
106	configPath,
107	relFsBasePath: "",
108	virBasePath,
109	}, config);
110
111	res.forEach((result) => {	72✔
112	result.filePath = transformVirtualPathToFilePath(result.filePath, "", "/");	78✔
113	});
114	// Sort by filePath after the virtual path has been converted back to ensure deterministic and sorted output.
115	// Differences in order can happen as different linters (e.g. xml, json, html, ui5.yaml) are executed in parallel.
116	sortLintResults(res);	72✔
117	return res;	72✔
118	}
119
120	async function lint(
121	resourceReader: AbstractReader, options: LinterOptions & FSToVirtualPathOptions,
122	config: UI5LintConfigType
123	): Promise<LintResult[]> {
124	const lintEnd = taskStart("Linting");	87✔
125	let {ignorePattern, filePatterns} = options;	87✔
126	const {relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest} = options;	87✔
127
128	// Resolve files to include
129	filePatterns = filePatterns ?? config.files ?? [];	87!
130
131	// Resolve ignores
132	ignorePattern = [	87✔
133	...(config.ignores ?? []),	165✔
134	...(ignorePattern ?? []), // CLI patterns go after config patterns	173✔
135	].filter(($) => $);	20✔
136	// Apply ignores to the workspace reader.
137	// TypeScript needs the full context to provide correct analysis.
138	// so, we can do filtering later via the filePathsReader
139	const reader = resolveReader({	87✔
140	patterns: ignorePattern,
141	resourceReader,
142	patternsMatch: matchedPatterns,
143	relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
144	});
145
146	// Apply files + ignores over the filePaths reader
147	let filePathsReader = resolveReader({	87✔
148	patterns: filePatterns,
149	resourceReader,
150	inverseResult: true,
151	patternsMatch: matchedPatterns,
152	relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
153	});
154	filePathsReader = resolveReader({	87✔
155	patterns: ignorePattern,
156	resourceReader: filePathsReader,
157	patternsMatch: matchedPatterns,
158	relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
159	});
160	const filePathsWorkspace = createWorkspace({reader: filePathsReader});	87✔
161
162	const workspace = createWorkspace({	87✔
163	reader,
164	});
165
166	const res = await lintWorkspace(workspace, filePathsWorkspace, options, config, matchedPatterns);	87✔
167	checkUnmatchedPatterns(filePatterns, matchedPatterns);	87✔
168
169	lintEnd();	86✔
170	return res;	86✔
171	}
172
173	async function getProjectGraph(rootDir: string, ui5ConfigPath?: string): Promise<ProjectGraph> {
174	let rootConfigPath, rootConfiguration;
175	const ui5YamlPath = ui5ConfigPath ? path.join(rootDir, ui5ConfigPath) : path.join(rootDir, "ui5.yaml");	16✔
176	if (await fileExists(ui5YamlPath)) {	16✔
177	rootConfigPath = ui5YamlPath;	12✔
178	} else {
179	if (ui5ConfigPath) throw new Error(`Unable to find UI5 config file '${ui5ConfigPath}'`);	4✔
180	const isApp = await dirExists(path.join(rootDir, "webapp"));	3✔
181	if (isApp) {	3!
182	rootConfiguration = {	×
183	specVersion: "3.0",
184	type: "application",
185	metadata: {
186	name: "ui5-linter-target",
187	},
188	};
189	} else {
190	const isLibrary = await dirExists(path.join(rootDir, "src"));	3✔
191	if (isLibrary) {	3!
192	rootConfiguration = {	3✔
193	specVersion: "3.0",
194	type: "library",
195	metadata: {
196	name: "ui5-linter-target",
197	},
198	};
199	}
200	}
201	}
202
203	if (!rootConfigPath && !rootConfiguration) {	15!
UNCOV 204	throw new Error(	×
205	`Unable to find a UI5 project at ${rootDir}. \n` +
206	`Please make sure to run "ui5lint" in the root directory of your UI5 project.`
207	);
208	}
209
210	return graphFromObject({	15✔
211	dependencyTree: {
212	id: "ui5-linter-target",
213	version: "1.0.0",
214	path: rootDir,
215	dependencies: [],
216	},
217	rootConfigPath,
218	rootConfiguration,
219	resolveFrameworkDependencies: false,
220	});
221	}
222
223	/**
224	* Normalize provided virtual paths to the original file paths
225	*/
226	function transformVirtualPathToFilePath(
227	virtualPath: string,
228	srcFsBasePath: string, srcVirBasePath: string,
229	testFsBasePath?: string, testVirBasePath?: string
230	): FilePath {
231	if (virtualPath.startsWith(srcVirBasePath)) {	2,227✔
232	return path.join(srcFsBasePath, posixPath.relative(srcVirBasePath, virtualPath));	2,203✔
233	} else if (testFsBasePath && testVirBasePath && virtualPath.startsWith(testVirBasePath)) {	24✔
234	return path.join(testFsBasePath, posixPath.relative(testVirBasePath, virtualPath));	10✔
235	} else if (virtualPath.startsWith("/")) {	14!
236	return posixPath.relative("/", virtualPath);	14✔
237	} else {
238	throw new Error(	×
239	`Resource path ${virtualPath} is not located within the virtual source or test directories of the project`);
240	}
241	}
242
243	async function fsStat(fsPath: string) {
244	try {	22✔
245	return await stat(fsPath);	22✔
246	// eslint-disable-next-line @typescript-eslint/no-explicit-any
247	} catch (err: any) {
248	// "File or directory does not exist"
249	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
250	if (err.code === "ENOENT") {	7!
251	return false;	7✔
252	} else {
253	throw err;	×
254	}
255	}
256	}
257
258	async function dirExists(dirPath: string) {
259	const stats = await fsStat(dirPath);	6✔
260	return stats && stats.isDirectory();	6✔
261	}
262
263	async function fileExists(dirPath: string) {
264	const stats = await fsStat(dirPath);	16✔
265	return stats && stats.isFile();	16✔
266	}
267
268	function sortLintResults(lintResults: LintResult[]) {
269	lintResults.sort((a, b) => a.filePath.localeCompare(b.filePath));	265✔
270	}
271
272	function isFileIncluded(file: string, patterns: Minimatch[], patternsMatch: Set<string>) {
273	let include = true;	2,042✔
274
275	for (const pattern of patterns) {	2,042✔
276	if (pattern.negate && pattern.match(file)) {	2,497✔
277	patternsMatch.add(pattern.pattern);	10✔
278	include = true; // re-include it	10✔
279	} else if (pattern.match(file)) { // Handle inclusion: exclude if it matches	2,487✔
280	patternsMatch.add(pattern.pattern);	218✔
281	include = false;	218✔
282	}
283	}
284
285	return include;	2,042✔
286	}
287
288	function buildPatterns(patterns: string[]) {
289	// Patterns must be only relative (to project's root),
290	// otherwise throw an error
291	return patterns.map((pattern) => {	179✔
292	let notNegatedPattern = pattern;	252✔
293	if (pattern.startsWith("!")) {	252✔
294	notNegatedPattern = pattern.slice(1);	21✔
295	}
296
297	if (path.isAbsolute(notNegatedPattern)) {	252!
298	throw Error(`Pattern must be relative to project's root folder. ` +	×
299	`"${pattern}" defines an absolute path.`);
300	}
301
302	if (pattern.endsWith("/")) { // Match all files in a directory	252✔
303	pattern += "*/";	8✔
304	}
305
306	return new Minimatch(pattern, {flipNegate: true});	252✔
307	});
308	}
309
310	export function resolveReader({
311	patterns,
312	resourceReader,
313	inverseResult = false,	261✔
314	patternsMatch,
315	relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest,
316	}: {
317	patterns: string[];
318	resourceReader: AbstractReader;
319	inverseResult?: boolean;
320	patternsMatch: Set<string>;
321	relFsBasePath: string; virBasePath: string; relFsBasePathTest?: string; virBasePathTest?: string;
322	}) {
323	if (!patterns.length) {	435✔
324	return resourceReader;	256✔
325	}
326
327	const minimatchPatterns = buildPatterns(patterns);	179✔
328
329	return createFilterReader({	179✔
330	reader: resourceReader,
331	callback: (resource: Resource) => {
332	// Minimatch works with FS and relative paths.
333	// So, we need to convert virtual paths to fs
334	const resPath = transformVirtualPathToFilePath(	2,042✔
335	resource.getPath(), relFsBasePath, virBasePath, relFsBasePathTest, virBasePathTest);
336
337	return inverseResult ?	2,042✔
338	// When we work with files paths we actually need to limit the result to those
339	// matches, instead of allowing all except XYZ
340	!isFileIncluded(resPath, minimatchPatterns, patternsMatch) :
341	isFileIncluded(resPath, minimatchPatterns, patternsMatch);
342	},
343	});
344	}
345
346	/**
347	* Checks which patterns were not matched during analysis
348	*
349	* @param patterns Available patterns
350	* @throws Error if an unmatched pattern is found
351	*/
352	function checkUnmatchedPatterns(patterns: FilePattern[], patternsMatch: Set<string>) {
353	const unmatchedPatterns = patterns.reduce((acc, pattern) => {	87✔
354	if (pattern.endsWith("/")) { // Match all files in a directory	105✔
355	pattern += "*/";	1✔
356	}
357	if (!patternsMatch.has(pattern)) {	105✔
358	acc.push(pattern);	3✔
359	}
360
361	return acc;	105✔
362	}, [] as FilePattern[]);
363
364	if (unmatchedPatterns.length) {	87✔
365	throw new Error(`Specified file ${unmatchedPatterns.length === 1 ? "pattern" : "patterns"}` +	1!
366	` '${unmatchedPatterns.join("', '")}' did not match any resource`);
367	}
368	}

SAP / ui5-linter / 11455074436

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