#2238

Build # #2238

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/b52ce34f50ee4c550079808b83011217304e3722">b52ce34f5<a href="https://github.com/markuplint/markuplint/commit/b52ce34f50ee4c550079808b83011217304e3722">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/484d5c8b3470d75109a77e4b4de35108a4c0fc4b">484d5c8b3</a>">484d5c8b3</a><a href="https://github.com/markuplint/markuplint/commit/b52ce34f50ee4c550079808b83011217304e3722"> into 9890efd6b">9890efd6b</a>

Run Details

3431 of 5018 branches covered (68.37%)

Branch coverage included in aggregate %.

318 of 318 new or added lines in 23 files covered. (100.0%)

6366 of 8824 relevant lines covered (72.14%)

278.39 hits per line

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

3.14

/packages/@markuplint/ml-core/src/ml-core.ts

import type { MLRule } from './ml-rule';
import type Ruleset from './ruleset';
import type { MLFabric, MLSchema } from './types';
import type { LocaleSet } from '@markuplint/i18n';
import type { MLASTDocument, MLMarkupLanguageParser, ParserOptions } from '@markuplint/ml-ast';
import type { RuleConfigValue, Violation } from '@markuplint/ml-config';

import { ParserError } from '@markuplint/parser-utils';

import { log, enableDebug } from './debug';
import { Document } from './ml-dom';

const resultLog = log.extend('result');

export type MLCoreParams = {
        sourceCode: string;
        filename: string;
        debug?: boolean;
} & MLFabric;

export class MLCore {
        #ast: MLASTDocument | null = null;
        #document!: Document<RuleConfigValue, unknown> | ParserError;
        #filename: string;
        #locale: LocaleSet;
        #parser: MLMarkupLanguageParser;
        #parserOptions: ParserOptions;
        #rules: MLRule<RuleConfigValue, unknown>[];
        #ruleset: Ruleset;
        #schemas: MLSchema;
        #sourceCode: string;

        constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename, debug }: MLCoreParams) {
                if (debug) {
                        enableDebug();
                }

                this.#parser = parser;
                this.#sourceCode = sourceCode;
                this.#parserOptions = parserOptions;
                this.#ruleset = {
                        rules: ruleset.rules ?? {},
                        nodeRules: ruleset.nodeRules ?? [],
                        childNodeRules: ruleset.childNodeRules ?? [],
                };
                this.#locale = locale;
                this.#schemas = schemas;
                this.#filename = filename;
                this.#rules = rules;

                this._parse();
                this._createDocument();
        }

        get document() {
                return this.#document;
        }

        setCode(sourceCode: string) {
                this.#sourceCode = sourceCode;
                this._parse();
                this._createDocument();
        }

        update({ parser, ruleset, rules, locale, schemas, parserOptions }: Partial<MLFabric>) {
                this.#parser = parser ?? this.#parser;
                this.#ruleset = {
                        rules: ruleset?.rules ?? this.#ruleset.rules,
                        nodeRules: ruleset?.nodeRules ?? this.#ruleset.nodeRules,
                        childNodeRules: ruleset?.childNodeRules ?? this.#ruleset.childNodeRules,
                };
                this.#rules = rules ?? this.#rules;
                this.#locale = locale ?? this.#locale;
                this.#schemas = schemas ?? this.#schemas;
                if (
                        parserOptions &&
                        (parserOptions.ignoreFrontMatter !== this.#parserOptions.ignoreFrontMatter ||
                                parserOptions.authoredElementName !== this.#parserOptions.authoredElementName)
                ) {
                        this._parse();
                }
                this._createDocument();
        }

        async verify(fix = false) {
                log('verify: start');
                const violations: Violation[] = [];
                if (this.#document instanceof ParserError) {
                        violations.push({
                                ruleId: 'parse-error',
                                severity: 'error',
                                message: this.#document.message,
                                col: this.#document.col,
                                line: this.#document.line,
                                raw: this.#document.raw,
                        });
                        log('verify: error %o', this.#document.message);
                        return violations;
                }

                for (const rule of this.#rules) {
                        const ruleInfo = rule.getRuleInfo(this.#ruleset, rule.name);
                        if (ruleInfo.disabled && ruleInfo.nodeRules.length === 0 && ruleInfo.childNodeRules.length === 0) {
                                continue;
                        }

                        log('%s Rule: verify', rule.name);
                        const results = await rule.verify(this.#document, this.#locale, fix).catch(e => {
                                if (e instanceof ParserError) {
                                        return e;
                                }
                                throw e;
                        });

                        if (results instanceof ParserError) {
                                log('%s Rule: verify error %o', rule.name, results.message);
                                violations.push({
                                        ruleId: 'parse-error',
                                        severity: 'error',
                                        message: results.message,
                                        col: results.col,
                                        line: results.line,
                                        raw: results.raw,
                                });
                        } else {
                                violations.push(...results);
                        }
                        log('%s Rule: verify end', rule.name);
                }
                if (resultLog.enabled) {
                        const { e, w, i } = violations.reduce(
                                (c, v) => {
                                        if (v.severity === 'error') c.e += 1;
                                        if (v.severity === 'warning') c.w += 1;
                                        if (v.severity === 'info') c.i += 1;
                                        return c;
                                },
                                { e: 0, w: 0, i: 0 },
                        );
                        resultLog('Error: %d', e);
                        resultLog('Warning: %d', w);
                        resultLog('Info: %d', i);
                }
                log('verify: end');
                return violations;
        }

        private _createDocument() {
                if (!this.#ast) {
                        return;
                }
                try {
                        this.#document = new Document(this.#ast, this.#ruleset, this.#schemas, {
                                filename: this.#filename,
                                endTag: this.#parser.endTag,
                        });
                } catch (err) {
                        if (err instanceof ParserError) {
                                this.#document = err;
                        } else {
                                throw err;
                        }
                }
        }

        private _parse() {
                try {
                        this.#ast = this.#parser.parse(this.#sourceCode, this.#parserOptions);
                } catch (err) {
                        log('Caught the parse error: %O', err);
                        this.#ast = null;
                        if (err instanceof ParserError) {
                                this.#document = err;
                        } else {
                                throw err;
                        }
                }
        }
}

1	import type { MLRule } from './ml-rule';
2	import type Ruleset from './ruleset';
3	import type { MLFabric, MLSchema } from './types';
4	import type { LocaleSet } from '@markuplint/i18n';
5	import type { MLASTDocument, MLMarkupLanguageParser, ParserOptions } from '@markuplint/ml-ast';
6	import type { RuleConfigValue, Violation } from '@markuplint/ml-config';
7
8	import { ParserError } from '@markuplint/parser-utils';	2✔
9
10	import { log, enableDebug } from './debug';	2✔
11	import { Document } from './ml-dom';	2✔
12
13	const resultLog = log.extend('result');	2✔
14
15	export type MLCoreParams = {
16	sourceCode: string;
17	filename: string;
18	debug?: boolean;
19	} & MLFabric;
20
21	export class MLCore {	2✔
22	#ast: MLASTDocument \| null = null;	×
23	#document!: Document<RuleConfigValue, unknown> \| ParserError;	×
24	#filename: string;	×
25	#locale: LocaleSet;	×
26	#parser: MLMarkupLanguageParser;	×
27	#parserOptions: ParserOptions;	×
28	#rules: MLRule<RuleConfigValue, unknown>[];	×
29	#ruleset: Ruleset;	×
30	#schemas: MLSchema;	×
31	#sourceCode: string;	×
32
33	constructor({ parser, sourceCode, ruleset, rules, locale, schemas, parserOptions, filename, debug }: MLCoreParams) {
34	if (debug) {	×
35	enableDebug();	×
36	}
37
38	this.#parser = parser;	×
39	this.#sourceCode = sourceCode;	×
40	this.#parserOptions = parserOptions;	×
41	this.#ruleset = {	×
42	rules: ruleset.rules ?? {},	×
43	nodeRules: ruleset.nodeRules ?? [],	×
44	childNodeRules: ruleset.childNodeRules ?? [],	×
45	};
46	this.#locale = locale;	×
47	this.#schemas = schemas;	×
48	this.#filename = filename;	×
49	this.#rules = rules;	×
50
51	this._parse();	×
52	this._createDocument();	×
53	}
54
55	get document() {
56	return this.#document;	×
57	}
58
59	setCode(sourceCode: string) {
60	this.#sourceCode = sourceCode;	×
61	this._parse();	×
62	this._createDocument();	×
63	}
64
65	update({ parser, ruleset, rules, locale, schemas, parserOptions }: Partial<MLFabric>) {
66	this.#parser = parser ?? this.#parser;	×
67	this.#ruleset = {	×
68	rules: ruleset?.rules ?? this.#ruleset.rules,	×
69	nodeRules: ruleset?.nodeRules ?? this.#ruleset.nodeRules,	×
70	childNodeRules: ruleset?.childNodeRules ?? this.#ruleset.childNodeRules,	×
71	};
72	this.#rules = rules ?? this.#rules;	×
73	this.#locale = locale ?? this.#locale;	×
74	this.#schemas = schemas ?? this.#schemas;	×
75	if (	×
76	parserOptions &&	×
77	(parserOptions.ignoreFrontMatter !== this.#parserOptions.ignoreFrontMatter \|\|
78	parserOptions.authoredElementName !== this.#parserOptions.authoredElementName)
79	) {
80	this._parse();	×
81	}
82	this._createDocument();	×
83	}
84
85	async verify(fix = false) {	×
86	log('verify: start');	×
87	const violations: Violation[] = [];	×
88	if (this.#document instanceof ParserError) {	×
89	violations.push({	×
90	ruleId: 'parse-error',
91	severity: 'error',
92	message: this.#document.message,
93	col: this.#document.col,
94	line: this.#document.line,
95	raw: this.#document.raw,
96	});
97	log('verify: error %o', this.#document.message);	×
98	return violations;	×
99	}
100
101	for (const rule of this.#rules) {	×
102	const ruleInfo = rule.getRuleInfo(this.#ruleset, rule.name);	×
103	if (ruleInfo.disabled && ruleInfo.nodeRules.length === 0 && ruleInfo.childNodeRules.length === 0) {	×
104	continue;	×
105	}
106
107	log('%s Rule: verify', rule.name);	×
108	const results = await rule.verify(this.#document, this.#locale, fix).catch(e => {	×
109	if (e instanceof ParserError) {	×
110	return e;	×
111	}
112	throw e;	×
113	});
114
115	if (results instanceof ParserError) {	×
116	log('%s Rule: verify error %o', rule.name, results.message);	×
117	violations.push({	×
118	ruleId: 'parse-error',
119	severity: 'error',
120	message: results.message,
121	col: results.col,
122	line: results.line,
123	raw: results.raw,
124	});
125	} else {
126	violations.push(...results);	×
127	}
128	log('%s Rule: verify end', rule.name);	×
129	}
130	if (resultLog.enabled) {	×
131	const { e, w, i } = violations.reduce(	×
132	(c, v) => {
133	if (v.severity === 'error') c.e += 1;	×
134	if (v.severity === 'warning') c.w += 1;	×
135	if (v.severity === 'info') c.i += 1;	×
136	return c;	×
137	},
138	{ e: 0, w: 0, i: 0 },
139	);
140	resultLog('Error: %d', e);	×
141	resultLog('Warning: %d', w);	×
142	resultLog('Info: %d', i);	×
143	}
144	log('verify: end');	×
145	return violations;	×
146	}
147
148	private _createDocument() {
149	if (!this.#ast) {	×
150	return;	×
151	}
152	try {	×
153	this.#document = new Document(this.#ast, this.#ruleset, this.#schemas, {	×
154	filename: this.#filename,
155	endTag: this.#parser.endTag,
156	});
157	} catch (err) {
158	if (err instanceof ParserError) {	×
159	this.#document = err;	×
160	} else {
161	throw err;	×
162	}
163	}
164	}
165
166	private _parse() {
167	try {	×
168	this.#ast = this.#parser.parse(this.#sourceCode, this.#parserOptions);	×
169	} catch (err) {
170	log('Caught the parse error: %O', err);	×
171	this.#ast = null;	×
172	if (err instanceof ParserError) {	×
173	this.#document = err;	×
174	} else {
175	throw err;	×
176	}
177	}
178	}
179	}

markuplint / markuplint / #2238

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