#2231

Build # #2231

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a040a0">63dceefe0<a href="https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a040a0">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/54aa1b2c98417607db5ce4540499a4ae8f75e104">54aa1b2c9</a>">54aa1b2c9</a><a href="https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a040a0"> into ebe184d30">ebe184d30</a>

Run Details

3431 of 5018 branches covered (68.37%)

Branch coverage included in aggregate %.

74 of 74 new or added lines in 24 files covered. (100.0%)

6365 of 8823 relevant lines covered (72.14%)

278.42 hits per line

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

1.56

/packages/@markuplint/ml-core/src/ml-dom/helper/debug.ts

import type { MLAttr } from '../node/attr';
import type { MLNode } from '../node/node';

export function nodeListToDebugMaps(nodeList: Readonly<MLNode<any, any>[]>, withAttr = false): string[] {
        return nodeList
                .map(n => {
                        const r: string[] = [];
                        if (n.is(n.ELEMENT_NODE) && n.isOmitted) {
                                r.push(`[N/A]>[N/A](N/A)${n.nodeName}: ${visibleWhiteSpace(n.raw)}`);
                                return r;
                        }
                        r.push(tokenDebug(n));
                        if (n.is(n.ELEMENT_NODE)) {
                                r.push(`  namespaceURI: ${!!n.namespaceURI}`);
                                r.push(`  elementType: ${n.elementType}`);
                                r.push(`  isInFragmentDocument: ${!!n.isInFragmentDocument}`);
                                r.push(`  isForeignElement: ${!!n.isForeignElement}`);
                                if (withAttr) {
                                        r.push(
                                                ...attributesToDebugMaps(n.attributes)
                                                        .flat()
                                                        .map(l => `  ${l}`),
                                        );
                                }
                        }
                        return r;
                })
                .flat();
}

function attributesToDebugMaps(attributes: ReadonlyArray<MLAttr<any, any>>): string[] {
        return attributes
                .map(n => {
                        const r = [
                                tokenDebug({
                                        name: n.name,
                                        startOffset: n.startOffset,
                                        endOffset: n.endOffset,
                                        startLine: n.startLine,
                                        endLine: n.endLine,
                                        startCol: n.startCol,
                                        endCol: n.endCol,
                                        raw: n.raw,
                                }),
                        ];
                        if (n.spacesBeforeName) {
                                r.push(`  ${tokenDebug(n.spacesBeforeName, 'bN')}`);
                        }
                        if (n.nameNode) {
                                r.push(`  ${tokenDebug(n.nameNode, 'name')}`);
                        }
                        if (n.spacesBeforeEqual) {
                                r.push(`  ${tokenDebug(n.spacesBeforeEqual, 'bE')}`);
                        }
                        if (n.equal) {
                                r.push(`  ${tokenDebug(n.equal, 'equal')}`);
                        }
                        if (n.spacesAfterEqual) {
                                r.push(`  ${tokenDebug(n.spacesAfterEqual, 'aE')}`);
                        }
                        if (n.startQuote) {
                                r.push(`  ${tokenDebug(n.startQuote, 'sQ')}`);
                        }
                        if (n.valueNode) {
                                r.push(`  ${tokenDebug(n.valueNode, 'value')}`);
                        }
                        if (n.endQuote) {
                                r.push(`  ${tokenDebug(n.endQuote, 'eQ')}`);
                        }
                        if (n.spacesBeforeName) {
                                r.push(`  isDirective: ${!!n.isDirective}`);
                                r.push(`  isDynamicValue: ${!!n.isDynamicValue}`);
                        }
                        if (n.candidate) {
                                r.push(`  candidate: ${visibleWhiteSpace(n.candidate)}`);
                        }
                        return r;
                })
                .flat();
}

function tokenDebug<
        N extends {
                startOffset: number;
                endOffset: number;
                startLine: number;
                endLine: number;
                startCol: number;
                endCol: number;
                nodeName?: string;
                name?: string;
                potentialName?: string;
                type?: string;
                raw: string;
        },
>(n: N, type = '') {
        return `[${n.startLine}:${n.startCol}]>[${n.endLine}:${n.endCol}](${n.startOffset},${n.endOffset})${
                n.nodeName || n.potentialName || n.name || n.type || type
        }: ${visibleWhiteSpace(n.raw)}`;
}

function visibleWhiteSpace(chars: string) {
        return chars.replace(/\n/g, '⏎').replace(/\t/g, '→').replace(/\s/g, '␣');
}

1	import type { MLAttr } from '../node/attr';
2	import type { MLNode } from '../node/node';
3
4	export function nodeListToDebugMaps(nodeList: Readonly<MLNode<any, any>[]>, withAttr = false): string[] {	3!
5	return nodeList	×
6	.map(n => {
7	const r: string[] = [];	×
8	if (n.is(n.ELEMENT_NODE) && n.isOmitted) {	×
9	r.push(`[N/A]>[N/A](N/A)${n.nodeName}: ${visibleWhiteSpace(n.raw)}`);	×
10	return r;	×
11	}
12	r.push(tokenDebug(n));	×
13	if (n.is(n.ELEMENT_NODE)) {	×
14	r.push(` namespaceURI: ${!!n.namespaceURI}`);	×
15	r.push(` elementType: ${n.elementType}`);	×
16	r.push(` isInFragmentDocument: ${!!n.isInFragmentDocument}`);	×
17	r.push(` isForeignElement: ${!!n.isForeignElement}`);	×
18	if (withAttr) {	×
19	r.push(	×
20	...attributesToDebugMaps(n.attributes)
21	.flat()
22	.map(l => ` ${l}`),	×
23	);
24	}
25	}
26	return r;	×
27	})
28	.flat();
29	}
30
31	function attributesToDebugMaps(attributes: ReadonlyArray<MLAttr<any, any>>): string[] {
32	return attributes	×
33	.map(n => {
34	const r = [	×
35	tokenDebug({
36	name: n.name,
37	startOffset: n.startOffset,
38	endOffset: n.endOffset,
39	startLine: n.startLine,
40	endLine: n.endLine,
41	startCol: n.startCol,
42	endCol: n.endCol,
43	raw: n.raw,
44	}),
45	];
46	if (n.spacesBeforeName) {	×
47	r.push(` ${tokenDebug(n.spacesBeforeName, 'bN')}`);	×
48	}
49	if (n.nameNode) {	×
50	r.push(` ${tokenDebug(n.nameNode, 'name')}`);	×
51	}
52	if (n.spacesBeforeEqual) {	×
53	r.push(` ${tokenDebug(n.spacesBeforeEqual, 'bE')}`);	×
54	}
55	if (n.equal) {	×
56	r.push(` ${tokenDebug(n.equal, 'equal')}`);	×
57	}
58	if (n.spacesAfterEqual) {	×
59	r.push(` ${tokenDebug(n.spacesAfterEqual, 'aE')}`);	×
60	}
61	if (n.startQuote) {	×
62	r.push(` ${tokenDebug(n.startQuote, 'sQ')}`);	×
63	}
64	if (n.valueNode) {	×
65	r.push(` ${tokenDebug(n.valueNode, 'value')}`);	×
66	}
67	if (n.endQuote) {	×
68	r.push(` ${tokenDebug(n.endQuote, 'eQ')}`);	×
69	}
70	if (n.spacesBeforeName) {	×
71	r.push(` isDirective: ${!!n.isDirective}`);	×
72	r.push(` isDynamicValue: ${!!n.isDynamicValue}`);	×
73	}
74	if (n.candidate) {	×
75	r.push(` candidate: ${visibleWhiteSpace(n.candidate)}`);	×
76	}
77	return r;	×
78	})
79	.flat();
80	}
81
82	function tokenDebug<
83	N extends {
84	startOffset: number;
85	endOffset: number;
86	startLine: number;
87	endLine: number;
88	startCol: number;
89	endCol: number;
90	nodeName?: string;
91	name?: string;
92	potentialName?: string;
93	type?: string;
94	raw: string;
95	},
96	>(n: N, type = '') {	×
97	return `[${n.startLine}:${n.startCol}]>[${n.endLine}:${n.endCol}](${n.startOffset},${n.endOffset})${	×
98	n.nodeName \|\| n.potentialName \|\| n.name \|\| n.type \|\| type	×
99	}: ${visibleWhiteSpace(n.raw)}`;
100	}
101
102	function visibleWhiteSpace(chars: string) {
103	return chars.replace(/\n/g, '⏎').replace(/\t/g, '→').replace(/\s/g, '␣');	×
104	}

markuplint / markuplint / #2231

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