#2232

Build # #2232

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/63dceefe0b49846010cce00631e25e1d36a040a0">63dceefe0<a href="https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a040a0">&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/63dceefe0b49846010cce00631e25e1d36a040a0&quot;&gt;63dceefe0&lt;/a&gt;&lt;a href=&quot;https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a040a0&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d&lt;/a&gt;36a040a0&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/markuplint/markuplint/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/54aa1b2c98417607db5ce4540499a4ae8f75e104">54aa1b2c9</a><a href="https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a040a0">&amp;quot;&amp;gt;54aa1b2c9&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;54aa1b2c9&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/markuplint/markuplint/commit/63dceefe0b49846010cce00631e25e1d36a04&lt;/a&gt;0a0&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/ebe184d30">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

94.92

/packages/@markuplint/pug-parser/src/parse.ts

import type { ASTBlock, ASTNode } from './pug-parser';
import type {
        MLASTDoctype,
        MLASTNode,
        MLASTParentNode,
        MLASTPreprocessorSpecificBlock,
        MLASTTag,
        Parse,
} from '@markuplint/ml-ast';

import { getNamespace, parse as htmlParser, isDocumentFragment, removeDeprecatedNode } from '@markuplint/html-parser';
import { detectElementType, ignoreFrontMatter, ParserError, tokenizer, uuid, walk } from '@markuplint/parser-utils';

import attrTokenizer from './attr-tokenizer';
import { pugParse } from './pug-parser';

export const parse: Parse = (rawCode, options) => {
        let unknownParseError: string | undefined;
        let nodeList: MLASTNode[];

        if (options?.ignoreFrontMatter) {
                rawCode = ignoreFrontMatter(rawCode);
        }

        try {
                const parser = new Parser(rawCode);
                nodeList = parser.getNodeList();
        } catch (err) {
                nodeList = [];
                if (err instanceof Error && 'msg' in err && 'line' in err && 'column' in err && 'src' in err) {
                        throw new ParserError(
                                // @ts-ignore
                                err.msg,
                                {
                                        // @ts-ignore
                                        line: err.line,
                                        // @ts-ignore
                                        col: err.column,
                                        // @ts-ignore
                                        raw: err.src,
                                },
                        );
                }
                unknownParseError = err instanceof Error ? err.message : new Error(`${err}`).message;
        }

        return {
                nodeList,
                isFragment: isDocumentFragment(rawCode),
                unknownParseError: unknownParseError,
        };
};

class Parser {
        #ast: ASTBlock;

        constructor(raw: string) {
                this.#ast = pugParse(raw);
                // console.log(JSON.stringify(this.#ast, null, 2));
        }

        getNodeList() {
                const nodeTree = this.traverse(this.#ast.nodes, null);
                return this.flattenNodes(nodeTree);
        }

        traverse(astNodes: ASTNode[], parentNode: MLASTParentNode | null = null): MLASTNode[] {
                const nodeList: MLASTNode[] = [];

                let prevNode: MLASTNode | null = null;
                for (const astNode of astNodes) {
                        const nodes = this.nodeize(astNode, prevNode, parentNode);
                        if (!nodes || (Array.isArray(nodes) && nodes.length === 0)) {
                                continue;
                        }

                        let node: MLASTNode;
                        if (Array.isArray(nodes)) {
                                node = nodes[nodes.length - 1];
                        } else {
                                node = nodes;
                        }

                        if (prevNode) {
                                if (node.type !== 'endtag') {
                                        prevNode.nextNode = node;
                                }
                                node.prevNode = prevNode;
                        }
                        prevNode = node;

                        if (Array.isArray(nodes)) {
                                nodeList.push(...nodes);
                        } else {
                                nodeList.push(nodes);
                        }
                }

                return nodeList;
        }

        nodeize(
                originNode: ASTNode,
                prevNode: MLASTNode | null,
                parentNode: MLASTParentNode | null,
        ): MLASTNode | MLASTNode[] | null {
                const nextNode = null;
                const startOffset = originNode.offset;
                const endOffset = originNode.endOffset;
                const startLine = originNode.line;
                const endLine = originNode.endLine;
                const startCol = originNode.column;
                const endCol = originNode.endColumn;
                const parentNamespace =
                        parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';

                switch (originNode.type) {
                        case 'Doctype': {
                                return {
                                        uuid: uuid(),
                                        raw: originNode.raw,
                                        name: originNode.val || '',
                                        // TODO:
                                        publicId: '',
                                        // TODO:
                                        systemId: '',
                                        startOffset,
                                        endOffset,
                                        startLine,
                                        endLine,
                                        startCol,
                                        endCol,
                                        nodeName: '#doctype',
                                        type: 'doctype',
                                        parentNode,
                                        prevNode,
                                        _addPrevNode: 102,
                                        nextNode,
                                        isFragment: false,
                                        isGhost: false,
                                } as MLASTDoctype;
                        }
                        case 'Text': {
                                if (parentNode && /^script$|^style$/i.test(parentNode.nodeName)) {
                                        return {
                                                uuid: uuid(),
                                                raw: originNode.raw,
                                                startOffset,
                                                endOffset,
                                                startLine,
                                                endLine,
                                                startCol,
                                                endCol,
                                                nodeName: '#text',
                                                type: 'text',
                                                parentNode,
                                                prevNode,
                                                nextNode,
                                                isFragment: false,
                                                isGhost: false,
                                        };
                                }
                                const htmlDoc = htmlParser(originNode.raw, {
                                        offsetOffset: originNode.offset,
                                        offsetLine: originNode.line - 1,
                                        offsetColumn: originNode.column - 1,
                                });
                                const nodes = htmlDoc.nodeList;
                                for (const node of nodes) {
                                        if (!node.parentNode) {
                                                node.parentNode = parentNode;
                                        }
                                }
                                return nodes;
                        }
                        case 'Comment': {
                                return {
                                        uuid: uuid(),
                                        raw: originNode.raw,
                                        startOffset,
                                        endOffset,
                                        startLine,
                                        endLine,
                                        startCol,
                                        endCol,
                                        nodeName: '#comment',
                                        type: 'comment',
                                        parentNode,
                                        prevNode,
                                        nextNode,
                                        isFragment: false,
                                        isGhost: false,
                                };
                        }
                        case 'Tag': {
                                const namespace = getNamespace(originNode.name, parentNamespace);
                                const tag: MLASTTag = {
                                        uuid: uuid(),
                                        raw: originNode.raw,
                                        startOffset,
                                        endOffset,
                                        startLine,
                                        endLine,
                                        startCol,
                                        endCol,
                                        nodeName: originNode.name,
                                        type: 'starttag',
                                        namespace,
                                        elementType: detectElementType(originNode.name),
                                        attributes: originNode.attrs.map(attr => attrTokenizer(attr)),
                                        hasSpreadAttr: false,
                                        parentNode,
                                        prevNode,
                                        nextNode,
                                        pearNode: null,
                                        selfClosingSolidus: tokenizer('', originNode.line, originNode.column, originNode.offset),
                                        endSpace: tokenizer('', originNode.line, originNode.column, originNode.offset),
                                        isFragment: false,
                                        isGhost: false,
                                        tagOpenChar: '',
                                        tagCloseChar: '',
                                };

                                if (originNode.block.nodes.length) {
                                        tag.childNodes = this.traverse(originNode.block.nodes, tag);
                                }

                                return tag;
                        }
                        default: {
                                const tag: MLASTPreprocessorSpecificBlock = {
                                        uuid: uuid(),
                                        raw: originNode.raw,
                                        startOffset,
                                        endOffset,
                                        startLine,
                                        endLine,
                                        startCol,
                                        endCol,
                                        type: 'psblock',
                                        nodeName: originNode.type,
                                        parentNode,
                                        prevNode,
                                        nextNode,
                                        isFragment: true,
                                        isGhost: false,
                                };

                                if ('block' in originNode && originNode.block?.nodes.length) {
                                        tag.childNodes = this.traverse(originNode.block.nodes, tag);
                                }

                                return tag;
                        }
                }
        }

        flattenNodes(nodeTree: MLASTNode[]) {
                const nodeOrders: MLASTNode[] = [];
                walk(nodeTree, node => {
                        nodeOrders.push(node);
                });

                removeDeprecatedNode(nodeOrders);

                return nodeOrders;
        }
}

1	import type { ASTBlock, ASTNode } from './pug-parser';
2	import type {
3	MLASTDoctype,
4	MLASTNode,
5	MLASTParentNode,
6	MLASTPreprocessorSpecificBlock,
7	MLASTTag,
8	Parse,
9	} from '@markuplint/ml-ast';
10
11	import { getNamespace, parse as htmlParser, isDocumentFragment, removeDeprecatedNode } from '@markuplint/html-parser';	1✔
12	import { detectElementType, ignoreFrontMatter, ParserError, tokenizer, uuid, walk } from '@markuplint/parser-utils';	1✔
13
14	import attrTokenizer from './attr-tokenizer';	1✔
15	import { pugParse } from './pug-parser';	1✔
16
17	export const parse: Parse = (rawCode, options) => {	1✔
18	let unknownParseError: string \| undefined;
19	let nodeList: MLASTNode[];
20
21	if (options?.ignoreFrontMatter) {	28✔
22	rawCode = ignoreFrontMatter(rawCode);	1✔
23	}
24
25	try {	28✔
26	const parser = new Parser(rawCode);	28✔
27	nodeList = parser.getNodeList();	27✔
28	} catch (err) {
29	nodeList = [];	1✔
30	if (err instanceof Error && 'msg' in err && 'line' in err && 'column' in err && 'src' in err) {	1✔
31	throw new ParserError(	1✔
32	// @ts-ignore
33	err.msg,
34	{
35	// @ts-ignore
36	line: err.line,
37	// @ts-ignore
38	col: err.column,
39	// @ts-ignore
40	raw: err.src,
41	},
42	);
43	}
44	unknownParseError = err instanceof Error ? err.message : new Error(`${err}`).message;	×
45	}
46
47	return {	27✔
48	nodeList,
49	isFragment: isDocumentFragment(rawCode),
50	unknownParseError: unknownParseError,
51	};
52	};
53
54	class Parser {
55	#ast: ASTBlock;	28✔
56
57	constructor(raw: string) {
58	this.#ast = pugParse(raw);	28✔
59	// console.log(JSON.stringify(this.#ast, null, 2));
60	}
61
62	getNodeList() {
63	const nodeTree = this.traverse(this.#ast.nodes, null);	27✔
64	return this.flattenNodes(nodeTree);	27✔
65	}
66
67	traverse(astNodes: ASTNode[], parentNode: MLASTParentNode \| null = null): MLASTNode[] {	×
68	const nodeList: MLASTNode[] = [];	95✔
69
70	let prevNode: MLASTNode \| null = null;	95✔
71	for (const astNode of astNodes) {	95✔
72	const nodes = this.nodeize(astNode, prevNode, parentNode);	117✔
73	if (!nodes \|\| (Array.isArray(nodes) && nodes.length === 0)) {	117✔
74	continue;	1✔
75	}
76
77	let node: MLASTNode;
78	if (Array.isArray(nodes)) {	116✔
79	node = nodes[nodes.length - 1];	29✔
80	} else {
81	node = nodes;	87✔
82	}
83
84	if (prevNode) {	116✔
85	if (node.type !== 'endtag') {	22✔
86	prevNode.nextNode = node;	22✔
87	}
88	node.prevNode = prevNode;	22✔
89	}
90	prevNode = node;	116✔
91
92	if (Array.isArray(nodes)) {	116✔
93	nodeList.push(...nodes);	29✔
94	} else {
95	nodeList.push(nodes);	87✔
96	}
97	}
98
99	return nodeList;	95✔
100	}
101
102	nodeize(
103	originNode: ASTNode,
104	prevNode: MLASTNode \| null,
105	parentNode: MLASTParentNode \| null,
106	): MLASTNode \| MLASTNode[] \| null {
107	const nextNode = null;	117✔
108	const startOffset = originNode.offset;	117✔
109	const endOffset = originNode.endOffset;	117✔
110	const startLine = originNode.line;	117✔
111	const endLine = originNode.endLine;	117✔
112	const startCol = originNode.column;	117✔
113	const endCol = originNode.endColumn;	117✔
114	const parentNamespace =
115	parentNode && 'namespace' in parentNode ? parentNode.namespace : 'http://www.w3.org/1999/xhtml';	117✔
116
117	switch (originNode.type) {	117✔
118	case 'Doctype': {
119	return {	1✔
120	uuid: uuid(),
121	raw: originNode.raw,
122	name: originNode.val \|\| '',	1!
123	// TODO:
124	publicId: '',
125	// TODO:
126	systemId: '',
127	startOffset,
128	endOffset,
129	startLine,
130	endLine,
131	startCol,
132	endCol,
133	nodeName: '#doctype',
134	type: 'doctype',
135	parentNode,
136	prevNode,
137	_addPrevNode: 102,
138	nextNode,
139	isFragment: false,
140	isGhost: false,
141	} as MLASTDoctype;
142	}
143	case 'Text': {
144	if (parentNode && /^script$\|^style$/i.test(parentNode.nodeName)) {	32✔
145	return {	2✔
146	uuid: uuid(),
147	raw: originNode.raw,
148	startOffset,
149	endOffset,
150	startLine,
151	endLine,
152	startCol,
153	endCol,
154	nodeName: '#text',
155	type: 'text',
156	parentNode,
157	prevNode,
158	nextNode,
159	isFragment: false,
160	isGhost: false,
161	};
162	}
163	const htmlDoc = htmlParser(originNode.raw, {	30✔
164	offsetOffset: originNode.offset,
165	offsetLine: originNode.line - 1,
166	offsetColumn: originNode.column - 1,
167	});
168	const nodes = htmlDoc.nodeList;	30✔
169	for (const node of nodes) {	30✔
170	if (!node.parentNode) {	54✔
171	node.parentNode = parentNode;	44✔
172	}
173	}
174	return nodes;	30✔
175	}
176	case 'Comment': {
177	return {	1✔
178	uuid: uuid(),
179	raw: originNode.raw,
180	startOffset,
181	endOffset,
182	startLine,
183	endLine,
184	startCol,
185	endCol,
186	nodeName: '#comment',
187	type: 'comment',
188	parentNode,
189	prevNode,
190	nextNode,
191	isFragment: false,
192	isGhost: false,
193	};
194	}
195	case 'Tag': {
196	const namespace = getNamespace(originNode.name, parentNamespace);	78✔
197	const tag: MLASTTag = {	78✔
198	uuid: uuid(),
199	raw: originNode.raw,
200	startOffset,
201	endOffset,
202	startLine,
203	endLine,
204	startCol,
205	endCol,
206	nodeName: originNode.name,
207	type: 'starttag',
208	namespace,
209	elementType: detectElementType(originNode.name),
210	attributes: originNode.attrs.map(attr => attrTokenizer(attr)),	38✔
211	hasSpreadAttr: false,
212	parentNode,
213	prevNode,
214	nextNode,
215	pearNode: null,
216	selfClosingSolidus: tokenizer('', originNode.line, originNode.column, originNode.offset),
217	endSpace: tokenizer('', originNode.line, originNode.column, originNode.offset),
218	isFragment: false,
219	isGhost: false,
220	tagOpenChar: '',
221	tagCloseChar: '',
222	};
223
224	if (originNode.block.nodes.length) {	78✔
225	tag.childNodes = this.traverse(originNode.block.nodes, tag);	64✔
226	}
227
228	return tag;	78✔
229	}
230	default: {
231	const tag: MLASTPreprocessorSpecificBlock = {	5✔
232	uuid: uuid(),
233	raw: originNode.raw,
234	startOffset,
235	endOffset,
236	startLine,
237	endLine,
238	startCol,
239	endCol,
240	type: 'psblock',
241	nodeName: originNode.type,
242	parentNode,
243	prevNode,
244	nextNode,
245	isFragment: true,
246	isGhost: false,
247	};
248
249	if ('block' in originNode && originNode.block?.nodes.length) {	5!
250	tag.childNodes = this.traverse(originNode.block.nodes, tag);	4✔
251	}
252
253	return tag;	5✔
254	}
255	}
256	}
257
258	flattenNodes(nodeTree: MLASTNode[]) {
259	const nodeOrders: MLASTNode[] = [];	27✔
260	walk(nodeTree, node => {	27✔
261	nodeOrders.push(node);	157✔
262	});
263
264	removeDeprecatedNode(nodeOrders);	27✔
265
266	return nodeOrders;	27✔
267	}
268	}

markuplint / markuplint / #2232

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