#2048

Build # #2048

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/c5a1a4da15e3c80373aee16070eb0d0fd7c20f6b">c5a1a4da1<a href="https://github.com/markuplint/markuplint/commit/c5a1a4da15e3c80373aee16070eb0d0fd7c20f6b">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/b5bebca3de547a665164c8e156c6877ad25c4d15">b5bebca3d</a>">b5bebca3d</a><a href="https://github.com/markuplint/markuplint/commit/c5a1a4da15e3c80373aee16070eb0d0fd7c20f6b"> into 39a6deefa">39a6deefa</a>

Run Details

3005 of 4430 branches covered (67.83%)

Branch coverage included in aggregate %.

30 of 30 new or added lines in 3 files covered. (100.0%)

5652 of 7955 relevant lines covered (71.05%)

84.12 hits per line

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

87.5

/packages/@markuplint/file-resolver/src/config-provider.ts

import type { MLFile } from './ml-file';
import type { ConfigSet, Nullable } from './types';
import type { Config } from '@markuplint/ml-config';

import path from 'path';

import { mergeConfig } from '@markuplint/ml-config';
import { getPreset } from '@markuplint/ml-core';

import { load as loadConfig, search } from './cosmiconfig';
import { cacheClear, resolvePlugins } from './resolve-plugins';
import { fileExists, nonNullableFilter, uuid } from './utils';

const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';

export class ConfigProvider {
        #store = new Map<string, Config>();
        #cache = new Map<string, ConfigSet>();
        #held = new Set<string>();
        #recursiveLoadKeyAndDepth = new Map<string, number>();

        set(config: Config, key?: string) {
                key = key || uuid();
                this.#store.set(key, config);
                return key;
        }

        async search(targetFile: MLFile) {
                if (!(await targetFile.dirExists())) {
                        return null;
                }
                const res = await search<Config>(targetFile.path, false);
                if (!res) {
                        return null;
                }
                const { filePath, config } = res;
                const pathResolvedConfig = this._pathResolve(config, filePath);
                this.#store.set(filePath, pathResolvedConfig);
                return filePath;
        }

        async resolve(targetFile: MLFile, names: Nullable<string>[], cache = true): Promise<ConfigSet> {
                if (!cache) {
                        this.#store.clear();
                        this.#cache.clear();
                        cacheClear();
                }

                const keys = names.filter(nonNullableFilter);
                const key = keys.join(KEY_SEPARATOR);
                const currentConfig = this.#cache.get(key);
                if (currentConfig) {
                        return currentConfig;
                }
                let configSet = await this._mergeConfigs(keys, cache);

                const plugins = await resolvePlugins(configSet.config.plugins);

                if (this.#held.size) {
                        const extendHelds = Array.from(this.#held.values());
                        for (const held of extendHelds) {
                                const [, prefix, namespace, name] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) || [];

                                switch (prefix) {
                                        case 'plugin:': {
                                                const plugin = plugins.find(plugin => plugin.name === namespace);
                                                const config = plugin?.configs?.[name];
                                                if (config) {
                                                        this.set(config, held);
                                                }
                                                break;
                                        }
                                        case 'markuplint:': {
                                                const config = await getPreset(namespace);
                                                if (config) {
                                                        this.set(config, held);
                                                }
                                                break;
                                        }
                                }
                        }

                        configSet = await this._mergeConfigs([...keys, ...extendHelds], cache);

                        this.#held.clear();
                }

                // Resolves `overrides`
                if (configSet.config.overrides) {
                        const overrides = configSet.config.overrides;
                        const globs = Object.keys(overrides);
                        for (const glob of globs) {
                                const isMatched = targetFile.matches(glob);
                                if (isMatched) {
                                        // Note: Original config disappears
                                        configSet.config = overrides[glob];
                                }
                        }
                }

                const result = {
                        ...configSet,
                        plugins,
                };

                this.#cache.set(key, result);
                return result;
        }

        private async _mergeConfigs(keys: string[], cache: boolean) {
                const resolvedKeys = new Set<string>();
                const errs: Error[] = [];
                for (const key of keys) {
                        this.#recursiveLoadKeyAndDepth.clear();
                        const keySet = await this._recursiveLoad(key, cache);
                        for (const k of keySet.stack) {
                                resolvedKeys.add(k);
                        }
                        if (keySet.errs) {
                                errs.push(...keySet.errs);
                        }
                }
                const configs = Array.from(resolvedKeys)
                        .map(name => this.#store.get(name))
                        .filter(nonNullableFilter);
                let resultConfig: Config = {};
                for (const config of configs) {
                        resultConfig = mergeConfig(resultConfig, config);
                }
                return {
                        config: resultConfig,
                        files: resolvedKeys,
                        errs,
                };
        }

        private async _recursiveLoad(
                key: string,
                cache: boolean,
                depth = 1,
        ): Promise<{ stack: Set<string>; errs: CircularReferenceError[] | null }> {
                const stack = new Set<string>();
                const errs: CircularReferenceError[] = [];

                const ancestorDepth = this.#recursiveLoadKeyAndDepth.get(key);
                if (ancestorDepth != null && ancestorDepth < depth) {
                        return {
                                stack,
                                errs: [new CircularReferenceError(`Circular reference detected: ${key}`)],
                        };
                }

                this.#recursiveLoadKeyAndDepth.set(key, depth);

                let config = this.#store.get(key) || null;
                if (!config) {
                        config = await this._load(key, cache);
                }

                if (!config) {
                        return { stack, errs: null };
                }

                const depKeys = config.extends ? (Array.isArray(config.extends) ? config.extends : [config.extends]) : null;
                if (depKeys) {
                        for (const depKey of depKeys) {
                                const keys = await this._recursiveLoad(depKey, cache, depth + 1);
                                for (const key of keys.stack) {
                                        stack.add(key);
                                }
                                if (keys.errs) {
                                        errs.push(...keys.errs);
                                }
                        }
                }

                stack.add(key);
                return { stack, errs };
        }

        private async _load(filePath: string, cache: boolean) {
                const entity = this.#store.get(filePath);
                if (entity) {
                        return entity;
                }

                if (isPrefixedName(filePath)) {
                        this.#held.add(filePath);
                        return null;
                }

                if (!moduleExists(filePath) && !path.isAbsolute(filePath)) {
                        throw new TypeError(`${filePath} is not an absolute path`);
                }

                const config = await load(filePath, cache);
                if (!config) {
                        return null;
                }

                const pathResolvedConfig = this._pathResolve(config, filePath);

                this.#store.set(filePath, pathResolvedConfig);
                return pathResolvedConfig;
        }

        private _pathResolve(config: Config, filePath: string): Config {
                const dir = path.dirname(filePath);
                return {
                        ...config,
                        extends: pathResolve(dir, config.extends),
                        plugins: pathResolve(dir, config.plugins, ['name']),
                        parser: pathResolve(dir, config.parser),
                        specs: pathResolve(dir, config.specs),
                        excludeFiles: pathResolve(dir, config.excludeFiles),
                        overrides: pathResolve(dir, config.overrides, undefined, true),
                };
        }
}

async function load(filePath: string, cache: boolean) {
        if (!fileExists(filePath) && moduleExists(filePath)) {
                const mod = await import(filePath);
                const config: Config | null = mod?.default || null;
                return config;
        }
        const res = await loadConfig<Config>(filePath, !cache);
        if (!res) {
                return null;
        }
        return res.config;
}

function pathResolve<T extends string | (string | Record<string, unknown>)[] | Record<string, unknown> | undefined>(
        dir: string,
        filePath?: T,
        resolveProps?: string[],
        resolveKey = false,
): T {
        if (filePath == null) {
                // @ts-ignore
                return undefined;
        }
        if (typeof filePath === 'string') {
                // @ts-ignore
                return resolve(dir, filePath);
        }
        if (Array.isArray(filePath)) {
                // @ts-ignore
                return filePath.map(fp => pathResolve(dir, fp, resolveProps));
        }
        const res: Record<string, unknown> = {};
        for (const [key, fp] of Object.entries(filePath)) {
                let _key = key;
                if (resolveKey) {
                        _key = resolve(dir, key);
                }
                if (typeof fp === 'string') {
                        if (!resolveProps) {
                                res[_key] = resolve(dir, fp);
                        } else if (resolveProps.includes(key)) {
                                res[_key] = resolve(dir, fp);
                        } else {
                                res[_key] = fp;
                        }
                } else {
                        res[_key] = fp;
                }
        }
        // @ts-ignore
        return res;
}

function resolve(dir: string, pathOrModName: string) {
        if (isPrefixedName(pathOrModName)) {
                return pathOrModName;
        }
        if (moduleExists(pathOrModName)) {
                return pathOrModName;
        }
        return path.resolve(dir, pathOrModName);
}

function moduleExists(name: string) {
        try {
                require.resolve(name);
        } catch (err) {
                if (
                        // @ts-ignore
                        'code' in err &&
                        // @ts-ignore
                        err.code === 'MODULE_NOT_FOUND'
                ) {
                        return false;
                }
                throw err;
        }

        return true;
}

function isPrefixedName(name: string) {
        return /^(?:markuplint|plugin):/.test(name);
}

class CircularReferenceError extends ReferenceError {
        name = 'CircularReferenceError';
}

1	import type { MLFile } from './ml-file';
2	import type { ConfigSet, Nullable } from './types';
3	import type { Config } from '@markuplint/ml-config';
4
5	import path from 'path';	1✔
6
7	import { mergeConfig } from '@markuplint/ml-config';	1✔
8	import { getPreset } from '@markuplint/ml-core';	1✔
9
10	import { load as loadConfig, search } from './cosmiconfig';	1✔
11	import { cacheClear, resolvePlugins } from './resolve-plugins';	1✔
12	import { fileExists, nonNullableFilter, uuid } from './utils';	1✔
13
14	const KEY_SEPARATOR = '__ML_CONFIG_MERGE__';	1✔
15
16	export class ConfigProvider {	1✔
17	#store = new Map<string, Config>();	1✔
18	#cache = new Map<string, ConfigSet>();	1✔
19	#held = new Set<string>();	1✔
20	#recursiveLoadKeyAndDepth = new Map<string, number>();	1✔
21
22	set(config: Config, key?: string) {
23	key = key \|\| uuid();	2!
24	this.#store.set(key, config);	2✔
25	return key;	2✔
26	}
27
28	async search(targetFile: MLFile) {
29	if (!(await targetFile.dirExists())) {	1!
30	return null;	×
31	}
32	const res = await search<Config>(targetFile.path, false);	1✔
33	if (!res) {	1!
34	return null;	×
35	}
36	const { filePath, config } = res;	1✔
37	const pathResolvedConfig = this._pathResolve(config, filePath);	1✔
38	this.#store.set(filePath, pathResolvedConfig);	1✔
39	return filePath;	1✔
40	}
41
42	async resolve(targetFile: MLFile, names: Nullable<string>[], cache = true): Promise<ConfigSet> {	5✔
43	if (!cache) {	5!
44	this.#store.clear();	×
45	this.#cache.clear();	×
46	cacheClear();	×
47	}
48
49	const keys = names.filter(nonNullableFilter);	5✔
50	const key = keys.join(KEY_SEPARATOR);	5✔
51	const currentConfig = this.#cache.get(key);	5✔
52	if (currentConfig) {	5!
53	return currentConfig;	×
54	}
55	let configSet = await this._mergeConfigs(keys, cache);	5✔
56
57	const plugins = await resolvePlugins(configSet.config.plugins);	5✔
58
59	if (this.#held.size) {	5✔
60	const extendHelds = Array.from(this.#held.values());	1✔
61	for (const held of extendHelds) {	1✔
62	const [, prefix, namespace, name] = held.match(/^([a-z]+:)([^/]+)(?:\/(.+))?$/) \|\| [];	2!
63
64	switch (prefix) {	2✔
65	case 'plugin:': {
66	const plugin = plugins.find(plugin => plugin.name === namespace);	5✔
67	const config = plugin?.configs?.[name];	1!
68	if (config) {	1✔
69	this.set(config, held);	1✔
70	}
71	break;	1✔
72	}
73	case 'markuplint:': {
74	const config = await getPreset(namespace);	1✔
75	if (config) {	1✔
76	this.set(config, held);	1✔
77	}
78	break;	1✔
79	}
80	}
81	}
82
83	configSet = await this._mergeConfigs([...keys, ...extendHelds], cache);	1✔
84
85	this.#held.clear();	1✔
86	}
87
88	// Resolves `overrides`
89	if (configSet.config.overrides) {	5✔
90	const overrides = configSet.config.overrides;	1✔
91	const globs = Object.keys(overrides);	1✔
92	for (const glob of globs) {	1✔
93	const isMatched = targetFile.matches(glob);	1✔
94	if (isMatched) {	1✔
95	// Note: Original config disappears
96	configSet.config = overrides[glob];	1✔
97	}
98	}
99	}
100
101	const result = {	5✔
102	...configSet,
103	plugins,
104	};
105
106	this.#cache.set(key, result);	5✔
107	return result;	5✔
108	}
109
110	private async _mergeConfigs(keys: string[], cache: boolean) {
111	const resolvedKeys = new Set<string>();	6✔
112	const errs: Error[] = [];	6✔
113	for (const key of keys) {	6✔
114	this.#recursiveLoadKeyAndDepth.clear();	8✔
115	const keySet = await this._recursiveLoad(key, cache);	8✔
116	for (const k of keySet.stack) {	8✔
117	resolvedKeys.add(k);	21✔
118	}
119	if (keySet.errs) {	8✔
120	errs.push(...keySet.errs);	8✔
121	}
122	}
123	const configs = Array.from(resolvedKeys)	6✔
124	.map(name => this.#store.get(name))	19✔
125	.filter(nonNullableFilter);
126	let resultConfig: Config = {};	6✔
127	for (const config of configs) {	6✔
128	resultConfig = mergeConfig(resultConfig, config);	19✔
129	}
130	return {	6✔
131	config: resultConfig,
132	files: resolvedKeys,
133	errs,
134	};
135	}
136
137	private async _recursiveLoad(
138	key: string,
139	cache: boolean,
140	depth = 1,	8✔
141	): Promise<{ stack: Set<string>; errs: CircularReferenceError[] \| null }> {
142	const stack = new Set<string>();	24✔
143	const errs: CircularReferenceError[] = [];	24✔
144
145	const ancestorDepth = this.#recursiveLoadKeyAndDepth.get(key);	24✔
146	if (ancestorDepth != null && ancestorDepth < depth) {	24✔
147	return {	1✔
148	stack,
149	errs: [new CircularReferenceError(`Circular reference detected: ${key}`)],
150	};
151	}
152
153	this.#recursiveLoadKeyAndDepth.set(key, depth);	23✔
154
155	let config = this.#store.get(key) \|\| null;	23✔
156	if (!config) {	23✔
157	config = await this._load(key, cache);	13✔
158	}
159
160	if (!config) {	23✔
161	return { stack, errs: null };	2✔
162	}
163
164	const depKeys = config.extends ? (Array.isArray(config.extends) ? config.extends : [config.extends]) : null;	21✔
165	if (depKeys) {	21✔
166	for (const depKey of depKeys) {	12✔
167	const keys = await this._recursiveLoad(depKey, cache, depth + 1);	16✔
168	for (const key of keys.stack) {	16✔
169	stack.add(key);	25✔
170	}
171	if (keys.errs) {	16✔
172	errs.push(...keys.errs);	14✔
173	}
174	}
175	}
176
177	stack.add(key);	21✔
178	return { stack, errs };	21✔
179	}
180
181	private async _load(filePath: string, cache: boolean) {
182	const entity = this.#store.get(filePath);	13✔
183	if (entity) {	13!
184	return entity;	×
185	}
186
187	if (isPrefixedName(filePath)) {	13✔
188	this.#held.add(filePath);	2✔
189	return null;	2✔
190	}
191
192	if (!moduleExists(filePath) && !path.isAbsolute(filePath)) {	11!
193	throw new TypeError(`${filePath} is not an absolute path`);	×
194	}
195
196	const config = await load(filePath, cache);	11✔
197	if (!config) {	11!
198	return null;	×
199	}
200
201	const pathResolvedConfig = this._pathResolve(config, filePath);	11✔
202
203	this.#store.set(filePath, pathResolvedConfig);	11✔
204	return pathResolvedConfig;	11✔
205	}
206
207	private _pathResolve(config: Config, filePath: string): Config {
208	const dir = path.dirname(filePath);	12✔
209	return {	12✔
210	...config,
211	extends: pathResolve(dir, config.extends),
212	plugins: pathResolve(dir, config.plugins, ['name']),
213	parser: pathResolve(dir, config.parser),
214	specs: pathResolve(dir, config.specs),
215	excludeFiles: pathResolve(dir, config.excludeFiles),
216	overrides: pathResolve(dir, config.overrides, undefined, true),
217	};
218	}
219	}
220
221	async function load(filePath: string, cache: boolean) {
222	if (!fileExists(filePath) && moduleExists(filePath)) {	11✔
223	const mod = await import(filePath);	2✔
224	const config: Config \| null = mod?.default \|\| null;	1!
225	return config;	1✔
226	}
227	const res = await loadConfig<Config>(filePath, !cache);	10✔
228	if (!res) {	10!
229	return null;	×
230	}
231	return res.config;	10✔
232	}
233
234	function pathResolve<T extends string \| (string \| Record<string, unknown>)[] \| Record<string, unknown> \| undefined>(
235	dir: string,
236	filePath?: T,
237	resolveProps?: string[],
238	resolveKey = false,	76✔
239	): T {
240	if (filePath == null) {	88✔
241	// @ts-ignore
242	return undefined;	59✔
243	}
244	if (typeof filePath === 'string') {	29✔
245	// @ts-ignore
246	return resolve(dir, filePath);	14✔
247	}
248	if (Array.isArray(filePath)) {	15✔
249	// @ts-ignore
250	return filePath.map(fp => pathResolve(dir, fp, resolveProps));	16✔
251	}
252	const res: Record<string, unknown> = {};	4✔
253	for (const [key, fp] of Object.entries(filePath)) {	4✔
254	let _key = key;	7✔
255	if (resolveKey) {	7✔
256	_key = resolve(dir, key);	1✔
257	}
258	if (typeof fp === 'string') {	7✔
259	if (!resolveProps) {	6!
260	res[_key] = resolve(dir, fp);	×
261	} else if (resolveProps.includes(key)) {	6✔
262	res[_key] = resolve(dir, fp);	3✔
263	} else {
264	res[_key] = fp;	3✔
265	}
266	} else {
267	res[_key] = fp;	1✔
268	}
269	}
270	// @ts-ignore
271	return res;	4✔
272	}
273
274	function resolve(dir: string, pathOrModName: string) {
275	if (isPrefixedName(pathOrModName)) {	18✔
276	return pathOrModName;	2✔
277	}
278	if (moduleExists(pathOrModName)) {	16✔
279	return pathOrModName;	3✔
280	}
281	return path.resolve(dir, pathOrModName);	13✔
282	}
283
284	function moduleExists(name: string) {
285	try {	28✔
286	require.resolve(name);	28✔
287	} catch (err) {
288	if (	13✔
289	// @ts-ignore
290	'code' in err &&	26✔
291	// @ts-ignore
292	err.code === 'MODULE_NOT_FOUND'
293	) {
294	return false;	13✔
295	}
296	throw err;	×
297	}
298
299	return true;	15✔
300	}
301
302	function isPrefixedName(name: string) {
303	return /^(?:markuplint\|plugin):/.test(name);	31✔
304	}
305
306	class CircularReferenceError extends ReferenceError {
307	name = 'CircularReferenceError';	1✔
308	}

markuplint / markuplint / #2048

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