#2376

Build # #2376

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/8cef00ded9691e66c415a003dc50fdd3a844d3f0">8cef00ded<a href="https://github.com/markuplint/markuplint/commit/8cef00ded9691e66c415a003dc50fdd3a844d3f0">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/d6fd0626f111cc62072da4b19728a7dedfddbb26">d6fd0626f</a>">d6fd0626f</a><a href="https://github.com/markuplint/markuplint/commit/8cef00ded9691e66c415a003dc50fdd3a844d3f0"> into fbf92e6ef">fbf92e6ef</a>

Run Details

3078 of 4364 branches covered (70.53%)

Branch coverage included in aggregate %.

5865 of 7650 relevant lines covered (76.67%)

94.75 hits per line

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

76.14

/packages/@markuplint/ml-config/src/utils.ts

import type { AnyRule, RuleConfigValue } from './types';

import mustache from 'mustache';

export function toRegxp(pattern: string) {
        const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);
        if (matched) {
                return new RegExp(matched[1], matched[2]);
        }
        return pattern;
}

export function regexSelectorMatches(reg: string, raw: string) {
        const res: Record<string, string> = {};
        const pattern = toRegxp(reg);
        const regex = pattern instanceof RegExp ? pattern : new RegExp(`^${pattern.trim()}$`);
        const matched = regex.exec(raw);
        if (!matched) {
                return null;
        }
        matched.forEach((val, i) => (res[`$${i}`] = val));
        return {
                ...res,
                ...matched.groups,
        };
}

type PlainData =
        | string
        | number
        | boolean
        | null
        | undefined
        | PlainData[]
        | {
                        [key: string]: PlainData;
          };

/**
 * Return undefined if the template doesn't include the variable that is set as a property in data.
 * But return template string without changes if it doesn't have a variable.
 *
 * @param template Mustache template string
 * @param data Captured string for replacement
 */
export function provideValue(template: string, data: Record<string, string>) {
        const ast = mustache.parse(template);
        if (ast.length === 1 && ast[0][0] === 'text') {
                // It doesn't have a variable
                return template;
        }
        const noDataResult = mustache.render(template, {});
        const result = mustache.render(template, data);
        // Assume variables are empty in the template if it matched.
        if (noDataResult === result) {
                return;
        }
        return result;
}

export function exchangeValueOnRule(rule: AnyRule, data: Record<string, string>): AnyRule | undefined {
        if (rule != null && typeof rule === 'object' && !Array.isArray(rule)) {
                if (rule.value != null) {
                        rule = {
                                ...rule,
                                value: exchangeValue(rule.value, data),
                        };
                }
                if (rule.option) {
                        rule = {
                                ...rule,
                                option: exchangeOption(rule.option as PlainData, data),
                        };
                }
                if (rule.reason != null) {
                        const exchangedValue = exchangeValue(rule.reason, data);
                        rule = {
                                ...rule,
                                reason: exchangedValue ? `${exchangedValue}` : undefined,
                        };
                }
                return rule;
        }
        return exchangeValue(rule, data);
}

function exchangeValue(rule: RuleConfigValue, data: Record<string, string>): RuleConfigValue | undefined {
        if (rule == null) {
                return rule;
        }
        if (typeof rule === 'string') {
                return provideValue(rule, data);
        }
        if (Array.isArray(rule)) {
                const ruleArray = rule
                        .map(val => {
                                if (typeof val === 'string') {
                                        return provideValue(val, data);
                                }
                                return val;
                        })
                        .filter(item => item !== undefined);
                return ruleArray.length ? ruleArray : undefined;
        }
        return rule;
}

function exchangeOption(optionValue: PlainData, data: Record<string, string>): PlainData | undefined {
        if (optionValue == null) {
                return optionValue;
        }
        if (typeof optionValue === 'boolean' || typeof optionValue === 'number') {
                return optionValue;
        }
        if (typeof optionValue === 'string') {
                return provideValue(optionValue, data);
        }
        if (Array.isArray(optionValue)) {
                return optionValue.map(v => exchangeOption(v, data));
        }
        const result: Record<string, PlainData> = {};
        Object.keys(optionValue).forEach(key => {
                result[key] = exchangeOption(optionValue[key], data);
        });
        return result;
}

1	import type { AnyRule, RuleConfigValue } from './types';
2
3	import mustache from 'mustache';	1✔
4
5	export function toRegxp(pattern: string) {	1✔
6	const matched = pattern.match(/^\/(.+)\/([ig]*)$/i);	3✔
7	if (matched) {	3✔
8	return new RegExp(matched[1], matched[2]);	3✔
9	}
10	return pattern;	×
11	}
12
13	export function regexSelectorMatches(reg: string, raw: string) {	1✔
14	const res: Record<string, string> = {};	3✔
15	const pattern = toRegxp(reg);	3✔
16	const regex = pattern instanceof RegExp ? pattern : new RegExp(`^${pattern.trim()}$`);	3!
17	const matched = regex.exec(raw);	3✔
18	if (!matched) {	3✔
19	return null;	1✔
20	}
21	matched.forEach((val, i) => (res[`$${i}`] = val));	4✔
22	return {	2✔
23	...res,
24	...matched.groups,
25	};
26	}
27
28	type PlainData =
29	\| string
30	\| number
31	\| boolean
32	\| null
33	\| undefined
34	\| PlainData[]
35	\| {
36	[key: string]: PlainData;
37	};
38
39	/**
40	* Return undefined if the template doesn't include the variable that is set as a property in data.
41	* But return template string without changes if it doesn't have a variable.
42	*
43	* @param template Mustache template string
44	* @param data Captured string for replacement
45	*/
46	export function provideValue(template: string, data: Record<string, string>) {	1✔
47	const ast = mustache.parse(template);	11✔
48	if (ast.length === 1 && ast[0][0] === 'text') {	11✔
49	// It doesn't have a variable
50	return template;	1✔
51	}
52	const noDataResult = mustache.render(template, {});	10✔
53	const result = mustache.render(template, data);	10✔
54	// Assume variables are empty in the template if it matched.
55	if (noDataResult === result) {	10✔
56	return;	1✔
57	}
58	return result;	9✔
59	}
60
61	export function exchangeValueOnRule(rule: AnyRule, data: Record<string, string>): AnyRule \| undefined {	1✔
62	if (rule != null && typeof rule === 'object' && !Array.isArray(rule)) {	4✔
63	if (rule.value != null) {	3✔
64	rule = {	3✔
65	...rule,
66	value: exchangeValue(rule.value, data),
67	};
68	}
69	if (rule.option) {	3✔
70	rule = {	1✔
71	...rule,
72	option: exchangeOption(rule.option as PlainData, data),
73	};
74	}
75	if (rule.reason != null) {	3✔
76	const exchangedValue = exchangeValue(rule.reason, data);	1✔
77	rule = {	1✔
78	...rule,
79	reason: exchangedValue ? `${exchangedValue}` : undefined,	1!
80	};
81	}
82	return rule;	3✔
83	}
84	return exchangeValue(rule, data);	1✔
85	}
86
87	function exchangeValue(rule: RuleConfigValue, data: Record<string, string>): RuleConfigValue \| undefined {
88	if (rule == null) {	5!
89	return rule;	×
90	}
91	if (typeof rule === 'string') {	5✔
92	return provideValue(rule, data);	5✔
93	}
94	if (Array.isArray(rule)) {	×
95	const ruleArray = rule	×
96	.map(val => {
97	if (typeof val === 'string') {	×
98	return provideValue(val, data);	×
99	}
100	return val;	×
101	})
102	.filter(item => item !== undefined);	×
103	return ruleArray.length ? ruleArray : undefined;	×
104	}
105	return rule;	×
106	}
107
108	function exchangeOption(optionValue: PlainData, data: Record<string, string>): PlainData \| undefined {
109	if (optionValue == null) {	6!
110	return optionValue;	×
111	}
112	if (typeof optionValue === 'boolean' \|\| typeof optionValue === 'number') {	6!
113	return optionValue;	×
114	}
115	if (typeof optionValue === 'string') {	6✔
116	return provideValue(optionValue, data);	3✔
117	}
118	if (Array.isArray(optionValue)) {	3✔
119	return optionValue.map(v => exchangeOption(v, data));	1✔
120	}
121	const result: Record<string, PlainData> = {};	2✔
122	Object.keys(optionValue).forEach(key => {	2✔
123	result[key] = exchangeOption(optionValue[key], data);	4✔
124	});
125	return result;	2✔
126	}

markuplint / markuplint / #2376

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