#2711

Build # #2711

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/aae92dca7fa6e60c267a8a44da6a5ead47558933">aae92dca7<a href="https://github.com/markuplint/markuplint/commit/aae92dca7fa6e60c267a8a44da6a5ead47558933">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/803cc5224193eba379ace262d2698a40a7d34505">803cc5224</a>">803cc5224</a><a href="https://github.com/markuplint/markuplint/commit/aae92dca7fa6e60c267a8a44da6a5ead47558933"> into 3c5d969bd">3c5d969bd</a>

Run Details

3606 of 5347 branches covered (67.44%)

Branch coverage included in aggregate %.

6583 of 9170 relevant lines covered (71.79%)

302.6 hits per line

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

93.44

/packages/@markuplint/rules/src/permitted-contents/represent-transparent-nodes.ts

import type { ChildNode, Options, Result, Specs } from './types';

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

import { order } from './order';
import { Collection, getChildNodesWithoutWhitespaces, isTransparent, matches } from './utils';

export const transparentMode = new Map<ChildNode, true>();

export function representTransparentNodes(
        nodes: ChildNode[],
        specs: Specs,
        options: Options,
): {
        nodes: ChildNode[];
        errors: Result[];
} {
        const result: ChildNode[] = [];
        const errors: Result[] = [];

        const parent = nodes[0]?.parentElement;

        if (parent) {
                const { errors: parentErrors } = representTransparentNodes([parent], specs, options);
                errors.push(...parentErrors);
        }

        for (const node of nodes) {
                if (!node.is(node.ELEMENT_NODE)) {
                        result.push(node);
                        continue;
                }

                const models = getContentModel(node, specs.specs);

                if (models == null || typeof models === 'boolean') {
                        result.push(node);
                        continue;
                }

                const noTransparentModels = models.filter(m => !isTransparent(m));

                if (noTransparentModels.length === models.length) {
                        result.push(node);
                        continue;
                }

                const collection = new Collection(getChildNodesWithoutWhitespaces(node));

                let unmatched: ChildNode[];

                if (noTransparentModels.length) {
                        const result = order(noTransparentModels, collection.unmatched, specs, options, Infinity);
                        unmatched = result.unmatched;
                } else {
                        unmatched = collection.unmatched;
                }

                const transparent = models.find(m => isTransparent(m));

                if (!transparent || !isTransparent(transparent)) {
                        throw new Error('Unreachable code');
                }

                for (const _child of unmatched) {
                        const child: ChildNode = _child;

                        if (transparentMode.has(child)) {
                                continue;
                        }

                        transparentMode.set(child, true);

                        if (child.is(child.ELEMENT_NODE)) {
                                const transparentCondMatched = matches(transparent.transparent, child, specs);

                                if (!transparentCondMatched.matched) {
                                        errors.push({
                                                type: 'TRANSPARENT_MODEL_DISALLOWS',
                                                matched: [],
                                                unmatched: [node],
                                                zeroMatch: false,
                                                query: transparent.transparent,
                                                hint: {
                                                        not: transparentCondMatched.not,
                                                        transparent: node,
                                                },
                                        });
                                        continue;
                                }
                        }

                        result.push(child);
                }
        }

        return {
                nodes: result,
                errors,
        };
}

1	import type { ChildNode, Options, Result, Specs } from './types';
2
3	import { getContentModel } from '@markuplint/ml-spec';	8✔
4
5	import { order } from './order';	8✔
6	import { Collection, getChildNodesWithoutWhitespaces, isTransparent, matches } from './utils';	8✔
7
8	export const transparentMode = new Map<ChildNode, true>();	8✔
9
10	export function representTransparentNodes(	8✔
11	nodes: ChildNode[],
12	specs: Specs,
13	options: Options,
14	): {
15	nodes: ChildNode[];
16	errors: Result[];
17	} {
18	const result: ChildNode[] = [];	671✔
19	const errors: Result[] = [];	671✔
20
21	const parent = nodes[0]?.parentElement;	671✔
22
23	if (parent) {	671✔
24	const { errors: parentErrors } = representTransparentNodes([parent], specs, options);	370✔
25	errors.push(...parentErrors);	370✔
26	}
27
28	for (const node of nodes) {	671✔
29	if (!node.is(node.ELEMENT_NODE)) {	681✔
30	result.push(node);	62✔
31	continue;	62✔
32	}
33
34	const models = getContentModel(node, specs.specs);	619✔
35
36	if (models == null \|\| typeof models === 'boolean') {	619✔
37	result.push(node);	53✔
38	continue;	53✔
39	}
40
41	const noTransparentModels = models.filter(m => !isTransparent(m));	986✔
42
43	if (noTransparentModels.length === models.length) {	566✔
44	result.push(node);	476✔
45	continue;	476✔
46	}
47
48	const collection = new Collection(getChildNodesWithoutWhitespaces(node));	90✔
49
50	let unmatched: ChildNode[];
51
52	if (noTransparentModels.length) {	90✔
53	const result = order(noTransparentModels, collection.unmatched, specs, options, Infinity);	24✔
54	unmatched = result.unmatched;	24✔
55	} else {
56	unmatched = collection.unmatched;	66✔
57	}
58
59	const transparent = models.find(m => isTransparent(m));	131✔
60
61	if (!transparent \|\| !isTransparent(transparent)) {	90!
62	throw new Error('Unreachable code');	×
63	}
64
65	for (const _child of unmatched) {	90✔
66	const child: ChildNode = _child;	89✔
67
68	if (transparentMode.has(child)) {	89!
69	continue;	×
70	}
71
72	transparentMode.set(child, true);	89✔
73
74	if (child.is(child.ELEMENT_NODE)) {	89✔
75	const transparentCondMatched = matches(transparent.transparent, child, specs);	85✔
76
77	if (!transparentCondMatched.matched) {	85✔
78	errors.push({	26✔
79	type: 'TRANSPARENT_MODEL_DISALLOWS',
80	matched: [],
81	unmatched: [node],
82	zeroMatch: false,
83	query: transparent.transparent,
84	hint: {
85	not: transparentCondMatched.not,
86	transparent: node,
87	},
88	});
89	continue;	26✔
90	}
91	}
92
93	result.push(child);	63✔
94	}
95	}
96
97	return {	671✔
98	nodes: result,
99	errors,
100	};
101	}

markuplint / markuplint / #2711

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