#2116

Build # #2116

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/<a class="double-link" href="https://git"><a class=hub.com/markuplint/markuplint/commit/<a class="double-link" href="https://git"><a class=hub.com/markuplint/markuplint/commit/<a class="double-link" href="https://git"><a class=hub.com/markuplint/markuplint/commit/cd4bda18620c1f5f5a8d723ea62490207ad22dc7">cd4bda186">&lt;a href=&quot;https://github.com/markuplint/markuplint/commit/</a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/markuplint/markuplint/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/markuplint/markuplint/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/markuplint/markuplint/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/markuplint/markuplint/commit/cd4bda18620c1f5f5a8d723ea62490207ad22dc7">cd4bda186</a><a href="https://github.com/markuplint/markuplint/commit/cd4bda18620c1f5f5a8d723ea62490207ad22dc7">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/markuplint/markuplint/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/markuplint/markuplint/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/markuplint/markuplint/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/markuplint/markuplint/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/markuplint/markuplint/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/markuplint/markuplint/commit/cd4bda18620c1f5f5a8d723ea62490207ad22dc7&quot;&gt;cd4bda186&lt;/a&gt;&lt;a href=&quot;https://github.com/markuplint/markuplint/commit/cd4bda18620c1f5f5a8d723ea62490207ad22dc7&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/markuplint/markuplint/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp... (continued)

Run Details

3346 of 4881 branches covered (68.55%)

Branch coverage included in aggregate %.

159 of 159 new or added lines in 1 file covered. (100.0%)

6278 of 8689 relevant lines covered (72.25%)

260.57 hits per line

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

78.63

/packages/@markuplint/rules/src/permitted-contents/content-model.ts

import type { Element as _Element } from '@markuplint/ml-core';
import type {
        Category,
        ContentModel,
        MLMLSpec,
        PermittedContent,
        PermittedContentChoice,
        PermittedContentInterleave,
        PermittedContentOneOrMore,
        PermittedContentOptional,
        PermittedContentRequire,
        PermittedContentSpec,
        PermittedContentZeroOrMore,
        Target,
} from '@markuplint/ml-spec';

import { contentModelCategoryToTagNames } from '@markuplint/ml-spec';

import { log } from '../debug';

const cmLog = log.extend('content-model');
const nodeLog = cmLog.extend('node');

type Element = _Element<TagRule[], Options>;
type ChildNode = Element['childNodes'][0];

type Result = Matched | Unmatched;

type Matched = {
        matched: true;
        type: 'MATCHED' | 'MATCHED_EMPTY_TEXT' | `__${string}`;
        mayEmptyText?: boolean;
};

type Unmatched = {
        matched: false;
        type: UnmatchedReason;
        el: ChildNode;
        _?: any;
};

type MissingNode = Omit<Unmatched, 'el'> & {
        type: MissingNodeReason;
};

type UnmatchedReason =
        | 'VOID_ELEMENT'
        | 'UNMATCHED_MODELS'
        | 'UNMATCHED_SELECTORS'
        | 'DISALLOWED_TEXT'
        | 'UNEXPECTED_EXTRA_NODE'
        | 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY'
        | MissingNodeReason
        | '__ORDERED_MODELS_EMPTY'
        | '__UNEVALUATED_ERROR'
        | `__${string}`;

type MissingNodeReason = 'MISSING_NODE' | 'MISSING_NODE_REQUIRED' | 'MISSING_NODE_ONE_OR_MORE';

type TagRule = ContentModel & { tag: string };
type Options = {
        ignoreHasMutableChildren: boolean;
};

export function contentModel(model: ContentModel, el: Element, specs: MLMLSpec): Result {
        const conditions = model.conditional ?? [];
        for (const cond of conditions) {
                if (el.matches(cond.condition)) {
                        return checkContent(cond.contents, el, specs);
                }
        }
        return checkContent(model.contents, el, specs);
}

function checkContent(contents: ContentModel['contents'], el: Element, specs: MLMLSpec): Result {
        if (contents === false) {
                return {
                        matched: false,
                        type: 'VOID_ELEMENT',
                        el,
                };
        }
        if (contents === true) {
                // Allows all elements
                return {
                        matched: true,
                        type: 'MATCHED',
                };
        }
        const result = checkStart(contents, Array.from(el.children), specs);

        if (!result.matched && !('el' in result)) {
                return {
                        ...result,
                        el,
                };
        }

        return result;
}

function checkStart(
        contents: ReadonlyArray<PermittedContent>,
        elements: ReadonlyArray<ChildNode>,
        specs: MLMLSpec,
): Result | MissingNode {
        return checkOrder(contents.slice(), elements.slice(), specs);
}

function checkOrder(
        /**
         * @breakable
         */
        models: PermittedContent[],
        /**
         * @breakable
         */
        elements: ChildNode[],
        specs: MLMLSpec,
): Result | MissingNode {
        let prevEvalIsEmptyTextMatched = false;
        const prevModel: PermittedContent | null = null;
        const prevEvaluatedNodes: ChildNode[] = [];

        while (models.length) {
                const model = models[0];

                if (isChoice(model)) {
                        throw new UnsupportedError('Choice');
                }

                if (isInterleave(model)) {
                        throw new UnsupportedError('Interleave');
                }

                if ('ignore' in model) {
                        throw new UnsupportedError('ignore');
                }

                if ('notAllowedDescendants' in model) {
                        throw new UnsupportedError('notAllowedDescendants');
                }

                const result = checkExistance(model, elements, specs);

                if (result.matched) {
                        if (result.emptyTextMatched) {
                                prevEvalIsEmptyTextMatched = true;
                        } else {
                                prevEvalIsEmptyTextMatched = false;
                        }
                        prevEvaluatedNodes.push(...result.evaulatedNodes);
                }

                if (!result.matched) {
                        prevEvaluatedNodes.push(...result.evaulatedNodes);
                        if (prevEvalIsEmptyTextMatched) {
                                if (prevModel) {
                                        models.unshift(prevModel);
                                }
                                elements.unshift(...prevEvaluatedNodes);
                                prevEvalIsEmptyTextMatched = false;
                                continue;
                        }
                        return {
                                matched: false,
                                type: result.type,
                                el: result.evaulatedNodes[result.evaulatedNodes.length - 1] ?? elements[0],
                        };
                }

                models.shift();
        }
        if (elements.length) {
                return {
                        matched: false,
                        type: 'UNEXPECTED_EXTRA_NODE',
                        el: elements[0],
                };
        }
        return {
                matched: true,
                type: 'MATCHED',
        };
}

function checkExistance(
        model: PermittedContent,
        elements: ChildNode[],
        specs: MLMLSpec,
):
        | (Matched & {
                        evaulatedNodes: ChildNode[];
                        emptyTextMatched: boolean;
          })
        | (Omit<Unmatched, 'el'> & {
                        evaulatedNodes: ChildNode[];
          }) {
        let min: number;
        let max: number;
        let needs: Target | PermittedContentSpec;
        let type: MissingNodeReason | undefined;
        let _type: 'require' | 'optional' | 'one or more' | 'zero or more';

        if (isRequire(model)) {
                min = model.min ?? 1;
                max = model.max ?? 1;
                needs = model.require;
                type = 'MISSING_NODE_REQUIRED';
                _type = 'require';
        } else if (isOptional(model)) {
                min = 0;
                max = model.max ?? 1;
                needs = model.optional;
                _type = 'optional';
        } else if (isOneOrMore(model)) {
                min = 1;
                max = model.max ?? Infinity;
                needs = model.oneOrMore;
                type = 'MISSING_NODE_ONE_OR_MORE';
                _type = 'one or more';
        } else if (isZeroOrMore(model)) {
                min = 0;
                max = model.max ?? Infinity;
                needs = model.zeroOrMore;
                _type = 'zero or more';
        } else {
                throw new Error('Unreachable code');
        }

        cmLog('%s: %o', _type, needs);

        const matchedList: Matched[] = [];
        const evaulatedNodes: ChildNode[] = [];

        let emptyTextMatched = false;
        // eslint-disable-next-line no-constant-condition
        while (true) {
                const result = checkNeeds(needs, elements, specs);
                if (result.matched) {
                        const evaulatedNode = elements.shift();
                        if (evaulatedNode) {
                                evaulatedNodes.push(evaulatedNode);
                        }
                        if (result.mayEmptyText) {
                                emptyTextMatched = true;
                        }
                        if (result.type === 'MATCHED_EMPTY_TEXT') {
                                if (matchedList.length === 0) {
                                        matchedList.push(result);
                                }
                                break;
                        }
                        matchedList.push(result);
                } else {
                        if (result.type === 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY') {
                                return {
                                        matched: true,
                                        type: 'MATCHED',
                                        evaulatedNodes,
                                        emptyTextMatched: true,
                                };
                        }
                        break;
                }
        }

        if (matchedList.length < min) {
                return {
                        matched: false,
                        type: type ?? 'MISSING_NODE',
                        evaulatedNodes,
                };
        }

        if (max < matchedList.length) {
                return {
                        matched: false,
                        type: 'UNEXPECTED_EXTRA_NODE',
                        evaulatedNodes,
                };
        }

        return {
                matched: true,
                type: 'MATCHED',
                evaulatedNodes,
                emptyTextMatched,
        };
}

function checkNeeds(needs: Target | PermittedContentSpec, nodes: ChildNode[], specs: MLMLSpec): Result | MissingNode {
        if (typeof needs === 'string') {
                return checkNode(needs, nodes[0], specs);
        }
        for (const need of needs) {
                if (typeof need === 'string') {
                        return checkNode(need, nodes[0], specs);
                }

                // TODO
                // const result = checkExistance(need, nodes, specs);
        }
        return {
                matched: true,
                type: 'MATCHED',
        };
}

function checkNode(query: string, node: ChildNode | undefined, specs: MLMLSpec): Result | MissingNode {
        const { selectors, hasText, hasCustom } = optCondition(query, specs);

        if (node == null) {
                if (hasText) {
                        nodeLog('<#text>.matches(%s) => ""', query);
                        return {
                                matched: true,
                                type: 'MATCHED_EMPTY_TEXT',
                                mayEmptyText: true,
                        };
                }
                return {
                        matched: false,
                        type: 'MISSING_NODE',
                };
        }

        if (node.is(node.TEXT_NODE)) {
                if (hasText) {
                        nodeLog('<#text>.matches(%s) => "%s"', query, node.raw.trim());
                        return {
                                matched: true,
                                type: 'MATCHED',
                                mayEmptyText: true,
                        };
                }

                if (node.isWhitespace()) {
                        nodeLog('<#text>.matches(%s) => WHITESPACE', query);
                        return {
                                matched: true,
                                type: 'MATCHED',
                                mayEmptyText: true,
                        };
                }

                return {
                        matched: false,
                        type: 'DISALLOWED_TEXT',
                        el: node,
                };
        }

        if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {
                // TODO
                nodeLog('%s.matches(%s) => PBlock', node.raw, query);
                return {
                        matched: true,
                        type: 'MATCHED',
                        mayEmptyText: !!hasText,
                };
        }

        if (node.is(node.ELEMENT_NODE)) {
                if (node.isCustomElement && hasCustom) {
                        nodeLog('%s.matches(%s) => CustomElement', node.raw, query);
                        return {
                                matched: true,
                                type: 'MATCHED',
                                mayEmptyText: !!hasText,
                        };
                }

                const matchedSelector = selectors.find(selector => node.matches(selector));
                nodeLog('%s.matches(%s) => %s', node.raw, query, matchedSelector ?? false);

                if (matchedSelector) {
                        return {
                                matched: true,
                                type: 'MATCHED',
                                mayEmptyText: !!hasText,
                        };
                }

                if (hasText) {
                        return {
                                matched: false,
                                type: 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY',
                                el: node,
                        };
                }

                return {
                        matched: false,
                        el: node,
                        type: 'UNMATCHED_SELECTORS',
                        _: query,
                };
        }

        return {
                matched: true,
                type: 'MATCHED',
                mayEmptyText: !!hasText,
        };
}

function optCondition(query: string, specs: MLMLSpec) {
        const _selectors: string[] = [];
        let hasCustom = false;
        let hasText = false;

        if (/^#/.test(query)) {
                const tags = contentModelCategoryToTagNames(query as Category, specs);
                if (tags.length === 0) {
                        throw new Error('${query} is empty');
                }
                _selectors.push(...tags);
        } else {
                _selectors.push(query);
        }

        const selectors: string[] = [];

        for (const selector of _selectors) {
                if (selector === '#custom') {
                        hasCustom = true;
                        continue;
                }
                if (selector === '#text') {
                        hasText = true;
                        continue;
                }
                selectors.push(selector);
        }

        return {
                selectors,
                hasCustom,
                hasText,
        };
}

function isRequire(content: PermittedContent): content is PermittedContentRequire {
        return 'require' in content;
}

function isOptional(content: PermittedContent): content is PermittedContentOptional {
        return 'optional' in content;
}

function isOneOrMore(content: PermittedContent): content is PermittedContentOneOrMore {
        return 'oneOrMore' in content;
}

function isZeroOrMore(content: PermittedContent): content is PermittedContentZeroOrMore {
        return 'zeroOrMore' in content;
}

function isChoice(content: PermittedContent): content is PermittedContentChoice {
        return 'choice' in content;
}

function isInterleave(content: PermittedContent): content is PermittedContentInterleave {
        return 'interleave' in content;
}

class UnsupportedError extends Error {}

1	import type { Element as _Element } from '@markuplint/ml-core';
2	import type {
3	Category,
4	ContentModel,
5	MLMLSpec,
6	PermittedContent,
7	PermittedContentChoice,
8	PermittedContentInterleave,
9	PermittedContentOneOrMore,
10	PermittedContentOptional,
11	PermittedContentRequire,
12	PermittedContentSpec,
13	PermittedContentZeroOrMore,
14	Target,
15	} from '@markuplint/ml-spec';
16
17	import { contentModelCategoryToTagNames } from '@markuplint/ml-spec';	1✔
18
19	import { log } from '../debug';	1✔
20
21	const cmLog = log.extend('content-model');	1✔
22	const nodeLog = cmLog.extend('node');	1✔
23
24	type Element = _Element<TagRule[], Options>;
25	type ChildNode = Element['childNodes'][0];
26
27	type Result = Matched \| Unmatched;
28
29	type Matched = {
30	matched: true;
31	type: 'MATCHED' \| 'MATCHED_EMPTY_TEXT' \| `__${string}`;
32	mayEmptyText?: boolean;
33	};
34
35	type Unmatched = {
36	matched: false;
37	type: UnmatchedReason;
38	el: ChildNode;
39	_?: any;
40	};
41
42	type MissingNode = Omit<Unmatched, 'el'> & {
43	type: MissingNodeReason;
44	};
45
46	type UnmatchedReason =
47	\| 'VOID_ELEMENT'
48	\| 'UNMATCHED_MODELS'
49	\| 'UNMATCHED_SELECTORS'
50	\| 'DISALLOWED_TEXT'
51	\| 'UNEXPECTED_EXTRA_NODE'
52	\| 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY'
53	\| MissingNodeReason
54	\| '__ORDERED_MODELS_EMPTY'
55	\| '__UNEVALUATED_ERROR'
56	\| `__${string}`;
57
58	type MissingNodeReason = 'MISSING_NODE' \| 'MISSING_NODE_REQUIRED' \| 'MISSING_NODE_ONE_OR_MORE';
59
60	type TagRule = ContentModel & { tag: string };
61	type Options = {
62	ignoreHasMutableChildren: boolean;
63	};
64
65	export function contentModel(model: ContentModel, el: Element, specs: MLMLSpec): Result {	1✔
66	const conditions = model.conditional ?? [];	30!
67	for (const cond of conditions) {	30✔
68	if (el.matches(cond.condition)) {	×
69	return checkContent(cond.contents, el, specs);	×
70	}
71	}
72	return checkContent(model.contents, el, specs);	30✔
73	}
74
75	function checkContent(contents: ContentModel['contents'], el: Element, specs: MLMLSpec): Result {
76	if (contents === false) {	30!
77	return {	×
78	matched: false,
79	type: 'VOID_ELEMENT',
80	el,
81	};
82	}
83	if (contents === true) {	30!
84	// Allows all elements
85	return {	×
86	matched: true,
87	type: 'MATCHED',
88	};
89	}
90	const result = checkStart(contents, Array.from(el.children), specs);	30✔
91
92	if (!result.matched && !('el' in result)) {	30!
93	return {	×
94	...result,
95	el,
96	};
97	}
98
99	return result;	30✔
100	}
101
102	function checkStart(
103	contents: ReadonlyArray<PermittedContent>,
104	elements: ReadonlyArray<ChildNode>,
105	specs: MLMLSpec,
106	): Result \| MissingNode {
107	return checkOrder(contents.slice(), elements.slice(), specs);	30✔
108	}
109
110	function checkOrder(
111	/**
112	* @breakable
113	*/
114	models: PermittedContent[],
115	/**
116	* @breakable
117	*/
118	elements: ChildNode[],
119	specs: MLMLSpec,
120	): Result \| MissingNode {
121	let prevEvalIsEmptyTextMatched = false;	30✔
122	const prevModel: PermittedContent \| null = null;	30✔
123	const prevEvaluatedNodes: ChildNode[] = [];	30✔
124
125	while (models.length) {	30✔
126	const model = models[0];	53✔
127
128	if (isChoice(model)) {	53!
129	throw new UnsupportedError('Choice');	×
130	}
131
132	if (isInterleave(model)) {	53!
133	throw new UnsupportedError('Interleave');	×
134	}
135
136	if ('ignore' in model) {	53!
137	throw new UnsupportedError('ignore');	×
138	}
139
140	if ('notAllowedDescendants' in model) {	53!
141	throw new UnsupportedError('notAllowedDescendants');	×
142	}
143
144	const result = checkExistance(model, elements, specs);	53✔
145
146	if (result.matched) {	53✔
147	if (result.emptyTextMatched) {	40✔
148	prevEvalIsEmptyTextMatched = true;	9✔
149	} else {
150	prevEvalIsEmptyTextMatched = false;	31✔
151	}
152	prevEvaluatedNodes.push(...result.evaulatedNodes);	40✔
153	}
154
155	if (!result.matched) {	53✔
156	prevEvaluatedNodes.push(...result.evaulatedNodes);	13✔
157	if (prevEvalIsEmptyTextMatched) {	13✔
158	if (prevModel) {	4!
159	models.unshift(prevModel);	×
160	}
161	elements.unshift(...prevEvaluatedNodes);	4✔
162	prevEvalIsEmptyTextMatched = false;	4✔
163	continue;	4✔
164	}
165	return {	9✔
166	matched: false,
167	type: result.type,
168	el: result.evaulatedNodes[result.evaulatedNodes.length - 1] ?? elements[0],	27✔
169	};
170	}
171
172	models.shift();	40✔
173	}
174	if (elements.length) {	21✔
175	return {	5✔
176	matched: false,
177	type: 'UNEXPECTED_EXTRA_NODE',
178	el: elements[0],
179	};
180	}
181	return {	16✔
182	matched: true,
183	type: 'MATCHED',
184	};
185	}
186
187	function checkExistance(
188	model: PermittedContent,
189	elements: ChildNode[],
190	specs: MLMLSpec,
191	):
192	\| (Matched & {
193	evaulatedNodes: ChildNode[];
194	emptyTextMatched: boolean;
195	})
196	\| (Omit<Unmatched, 'el'> & {
197	evaulatedNodes: ChildNode[];
198	}) {
199	let min: number;
200	let max: number;
201	let needs: Target \| PermittedContentSpec;
202	let type: MissingNodeReason \| undefined;
203	let _type: 'require' \| 'optional' \| 'one or more' \| 'zero or more';
204
205	if (isRequire(model)) {	53✔
206	min = model.min ?? 1;	36!
207	max = model.max ?? 1;	36!
208	needs = model.require;	36✔
209	type = 'MISSING_NODE_REQUIRED';	36✔
210	_type = 'require';	36✔
211	} else if (isOptional(model)) {	17✔
212	min = 0;	7✔
213	max = model.max ?? 1;	7!
214	needs = model.optional;	7✔
215	_type = 'optional';	7✔
216	} else if (isOneOrMore(model)) {	10✔
217	min = 1;	5✔
218	max = model.max ?? Infinity;	5!
219	needs = model.oneOrMore;	5✔
220	type = 'MISSING_NODE_ONE_OR_MORE';	5✔
221	_type = 'one or more';	5✔
222	} else if (isZeroOrMore(model)) {	5!
223	min = 0;	5✔
224	max = model.max ?? Infinity;	5!
225	needs = model.zeroOrMore;	5✔
226	_type = 'zero or more';	5✔
227	} else {
228	throw new Error('Unreachable code');	×
229	}
230
231	cmLog('%s: %o', _type, needs);	53✔
232
233	const matchedList: Matched[] = [];	53✔
234	const evaulatedNodes: ChildNode[] = [];	53✔
235
236	let emptyTextMatched = false;	53✔
237	// eslint-disable-next-line no-constant-condition
238	while (true) {	53✔
239	const result = checkNeeds(needs, elements, specs);	107✔
240	if (result.matched) {	107✔
241	const evaulatedNode = elements.shift();	61✔
242	if (evaulatedNode) {	61✔
243	evaulatedNodes.push(evaulatedNode);	54✔
244	}
245	if (result.mayEmptyText) {	61✔
246	emptyTextMatched = true;	13✔
247	}
248	if (result.type === 'MATCHED_EMPTY_TEXT') {	61✔
249	if (matchedList.length === 0) {	7✔
250	matchedList.push(result);	3✔
251	}
252	break;	7✔
253	}
254	matchedList.push(result);	54✔
255	} else {
256	if (result.type === 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY') {	46✔
257	return {	3✔
258	matched: true,
259	type: 'MATCHED',
260	evaulatedNodes,
261	emptyTextMatched: true,
262	};
263	}
264	break;	43✔
265	}
266	}
267
268	if (matchedList.length < min) {	50✔
269	return {	11✔
270	matched: false,
271	type: type ?? 'MISSING_NODE',	33!
272	evaulatedNodes,
273	};
274	}
275
276	if (max < matchedList.length) {	39✔
277	return {	2✔
278	matched: false,
279	type: 'UNEXPECTED_EXTRA_NODE',
280	evaulatedNodes,
281	};
282	}
283
284	return {	37✔
285	matched: true,
286	type: 'MATCHED',
287	evaulatedNodes,
288	emptyTextMatched,
289	};
290	}
291
292	function checkNeeds(needs: Target \| PermittedContentSpec, nodes: ChildNode[], specs: MLMLSpec): Result \| MissingNode {
293	if (typeof needs === 'string') {	107✔
294	return checkNode(needs, nodes[0], specs);	107✔
295	}
296	for (const need of needs) {	×
297	if (typeof need === 'string') {	×
298	return checkNode(need, nodes[0], specs);	×
299	}
300
301	// TODO
302	// const result = checkExistance(need, nodes, specs);
303	}
304	return {	×
305	matched: true,
306	type: 'MATCHED',
307	};
308	}
309
310	function checkNode(query: string, node: ChildNode \| undefined, specs: MLMLSpec): Result \| MissingNode {
311	const { selectors, hasText, hasCustom } = optCondition(query, specs);	107✔
312
313	if (node == null) {	107✔
314	if (hasText) {	32✔
315	nodeLog('<#text>.matches(%s) => ""', query);	7✔
316	return {	7✔
317	matched: true,
318	type: 'MATCHED_EMPTY_TEXT',
319	mayEmptyText: true,
320	};
321	}
322	return {	25✔
323	matched: false,
324	type: 'MISSING_NODE',
325	};
326	}
327
328	if (node.is(node.TEXT_NODE)) {	75!
329	if (hasText) {	×
330	nodeLog('<#text>.matches(%s) => "%s"', query, node.raw.trim());	×
331	return {	×
332	matched: true,
333	type: 'MATCHED',
334	mayEmptyText: true,
335	};
336	}
337
338	if (node.isWhitespace()) {	×
339	nodeLog('<#text>.matches(%s) => WHITESPACE', query);	×
340	return {	×
341	matched: true,
342	type: 'MATCHED',
343	mayEmptyText: true,
344	};
345	}
346
347	return {	×
348	matched: false,
349	type: 'DISALLOWED_TEXT',
350	el: node,
351	};
352	}
353
354	if (node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK)) {	75!
355	// TODO
356	nodeLog('%s.matches(%s) => PBlock', node.raw, query);	×
357	return {	×
358	matched: true,
359	type: 'MATCHED',
360	mayEmptyText: !!hasText,
361	};
362	}
363
364	if (node.is(node.ELEMENT_NODE)) {	75✔
365	if (node.isCustomElement && hasCustom) {	75!
366	nodeLog('%s.matches(%s) => CustomElement', node.raw, query);	×
367	return {	×
368	matched: true,
369	type: 'MATCHED',
370	mayEmptyText: !!hasText,
371	};
372	}
373
374	const matchedSelector = selectors.find(selector => node.matches(selector));	577✔
375	nodeLog('%s.matches(%s) => %s', node.raw, query, matchedSelector ?? false);	75✔
376
377	if (matchedSelector) {	75✔
378	return {	54✔
379	matched: true,
380	type: 'MATCHED',
381	mayEmptyText: !!hasText,
382	};
383	}
384
385	if (hasText) {	21✔
386	return {	3✔
387	matched: false,
388	type: 'UNMATCHED_SELECTOR_BUT_MAY_EMPTY',
389	el: node,
390	};
391	}
392
393	return {	18✔
394	matched: false,
395	el: node,
396	type: 'UNMATCHED_SELECTORS',
397	_: query,
398	};
399	}
400
401	return {	×
402	matched: true,
403	type: 'MATCHED',
404	mayEmptyText: !!hasText,
405	};
406	}
407
408	function optCondition(query: string, specs: MLMLSpec) {
409	const _selectors: string[] = [];	107✔
410	let hasCustom = false;	107✔
411	let hasText = false;	107✔
412
413	if (/^#/.test(query)) {	107✔
414	const tags = contentModelCategoryToTagNames(query as Category, specs);	16✔
415	if (tags.length === 0) {	16!
416	throw new Error('${query} is empty');	×
417	}
418	_selectors.push(...tags);	16✔
419	} else {
420	_selectors.push(query);	91✔
421	}
422
423	const selectors: string[] = [];	107✔
424
425	for (const selector of _selectors) {	107✔
426	if (selector === '#custom') {	1,627✔
427	hasCustom = true;	16✔
428	continue;	16✔
429	}
430	if (selector === '#text') {	1,611✔
431	hasText = true;	16✔
432	continue;	16✔
433	}
434	selectors.push(selector);	1,595✔
435	}
436
437	return {	107✔
438	selectors,
439	hasCustom,
440	hasText,
441	};
442	}
443
444	function isRequire(content: PermittedContent): content is PermittedContentRequire {
445	return 'require' in content;	53✔
446	}
447
448	function isOptional(content: PermittedContent): content is PermittedContentOptional {
449	return 'optional' in content;	17✔
450	}
451
452	function isOneOrMore(content: PermittedContent): content is PermittedContentOneOrMore {
453	return 'oneOrMore' in content;	10✔
454	}
455
456	function isZeroOrMore(content: PermittedContent): content is PermittedContentZeroOrMore {
457	return 'zeroOrMore' in content;	5✔
458	}
459
460	function isChoice(content: PermittedContent): content is PermittedContentChoice {
461	return 'choice' in content;	53✔
462	}
463
464	function isInterleave(content: PermittedContent): content is PermittedContentInterleave {
465	return 'interleave' in content;	53✔
466	}
467
468	class UnsupportedError extends Error {}

markuplint / markuplint / #2116

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