#2633

Build # #2633

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/19bdaa225e01d87ec33cc4c489d7b173075c0828">19bdaa225<a href="https://github.com/markuplint/markuplint/commit/19bdaa225e01d87ec33cc4c489d7b173075c0828">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/0a97e418714c586dc0aa6c211a7f56360a88ecaf">0a97e4187</a>">0a97e4187</a><a href="https://github.com/markuplint/markuplint/commit/19bdaa225e01d87ec33cc4c489d7b173075c0828"> into 8d73dc85f">8d73dc85f</a>

Run Details

3606 of 5344 branches covered (67.48%)

Branch coverage included in aggregate %.

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

6587 of 9156 relevant lines covered (71.94%)

303.0 hits per line

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

77.11

/packages/@markuplint/parser-utils/src/ignore-block.ts

import type { Code, IgnoreBlock, IgnoreTag } from './types';
import type { MLASTNode, MLASTPreprocessorSpecificBlock, MLASTText } from '@markuplint/ml-ast';

import { MASK_CHAR } from './const';
import { uuid } from './create-token';
import { sliceFragment } from './get-location';
import { siblingsCorrection } from './siblings-correction';

export function ignoreBlock(source: string, tags: IgnoreTag[], maskChar = MASK_CHAR): IgnoreBlock {
        let replaced = source;
        const stack: Code[] = [];
        for (const tag of tags) {
                // Replace tags in attributes
                const attr = maskText(
                        prepend(tag.start, '(?<=(?:"|\'))'),
                        append(tag.end, '(?=(?:"|\'))'),
                        replaced,
                        (startTag, taggedCode, endTag) => {
                                const mask =
                                        maskChar.repeat(startTag.length) +
                                        taggedCode.replace(/[^\n]/g, maskChar) +
                                        maskChar.repeat((endTag || '').length);
                                return mask;
                        },
                );
                replaced = attr.replaced;
                stack.push(...attr.stack.map(res => ({ ...res, type: tag.type })));

                // Replace tags in other nodes
                const text = maskText(tag.start, tag.end, replaced, (startTag, taggedCode, endTag) => {
                        const mask =
                                maskChar.repeat(startTag.length) +
                                taggedCode.replace(/[^\n]/g, maskChar) +
                                maskChar.repeat((endTag || '').length);
                        const taggedMask = `<!${mask.slice(2).slice(0, -1)}>`;
                        return taggedMask;
                });
                replaced = text.replaced;
                stack.push(...text.stack.map(res => ({ ...res, type: tag.type })));
        }
        stack.sort((a, b) => a.index - b.index);

        return {
                source,
                replaced,
                stack,
                maskChar,
        };
}

function maskText(
        start: RegExp,
        end: RegExp,
        replaced: string,
        masking: (startTag: string, taggedCode: string, endTag?: string) => string,
) {
        const stack: Omit<Code, 'type'>[] = [];
        start = removeGlobalOption(start);
        end = removeGlobalOption(end);
        while (start.test(replaced)) {
                const [index, above, startTag, _below] = snap(replaced, start);
                if (!startTag || !_below) {
                        continue;
                }
                const [, taggedCode, endTag, below] = snap(_below, end);
                stack.push({
                        index,
                        startTag,
                        taggedCode,
                        endTag: endTag || null,
                });
                /**
                 * It will not replace line breaks because detects line number.
                 */
                replaced = above + masking(startTag, taggedCode, endTag) + (below || '');
        }
        return {
                replaced,
                stack,
        };
}

export function restoreNode(nodeList: MLASTNode[], ignoreBlock: IgnoreBlock) {
        nodeList = nodeList.slice();
        const { source, stack, maskChar } = ignoreBlock;
        for (const node of nodeList) {
                if (node.type === 'comment' || node.type === 'text' || node.type === 'psblock') {
                        if (!hasIgnoreBlock(node.raw, maskChar)) {
                                continue;
                        }
                        const parentNode = node.parentNode;
                        const index = nodeList.findIndex(n => n === node);
                        const insertList: (MLASTText | MLASTPreprocessorSpecificBlock)[] = [];
                        let text = node.raw;
                        let pointer = 0;
                        for (const tag of stack) {
                                if (node.startOffset <= tag.index && tag.index < node.endOffset) {
                                        const start = tag.index - node.startOffset;
                                        const body = tag.startTag + tag.taggedCode + (tag.endTag || '');
                                        const above = node.raw.slice(pointer, start);
                                        const below = text.slice(above.length + body.length);
                                        if (above) {
                                                const offset = node.startOffset + pointer;
                                                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(
                                                        source,
                                                        offset,
                                                        offset + above.length,
                                                );
                                                const textNode: MLASTText = {
                                                        ...node,
                                                        uuid: uuid(),
                                                        type: 'text',
                                                        raw,
                                                        startOffset,
                                                        endOffset,
                                                        startLine,
                                                        endLine,
                                                        startCol,
                                                        endCol,
                                                };
                                                if (node.prevNode?.nextNode) {
                                                        node.prevNode.nextNode = textNode;
                                                }
                                                if (node.nextNode?.prevNode) {
                                                        node.nextNode.prevNode = textNode;
                                                }
                                                insertList.push(textNode);
                                        }
                                        if (body) {
                                                const offset = node.startOffset + pointer + above.length;
                                                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(
                                                        source,
                                                        offset,
                                                        offset + body.length,
                                                );
                                                const bodyNode: MLASTPreprocessorSpecificBlock = {
                                                        uuid: uuid(),
                                                        type: 'psblock',
                                                        nodeName: `#ps:${tag.type}`,
                                                        raw,
                                                        parentNode: node.parentNode,
                                                        prevNode: null,
                                                        nextNode: null,
                                                        isFragment: node.isFragment,
                                                        isGhost: false,
                                                        startOffset,
                                                        endOffset,
                                                        startLine,
                                                        endLine,
                                                        startCol,
                                                        endCol,
                                                };
                                                if (node.prevNode?.nextNode) {
                                                        node.prevNode.nextNode = bodyNode;
                                                }
                                                if (node.nextNode?.prevNode) {
                                                        node.nextNode.prevNode = bodyNode;
                                                }
                                                insertList.push(bodyNode);
                                        }
                                        text = below;
                                        pointer = start + body.length;
                                }
                        }
                        if (text) {
                                const offset = node.endOffset - text.length;
                                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(
                                        source,
                                        offset,
                                        offset + text.length,
                                );
                                const textNode: MLASTText = {
                                        ...node,
                                        uuid: uuid(),
                                        type: 'text',
                                        raw,
                                        startOffset,
                                        endOffset,
                                        startLine,
                                        endLine,
                                        startCol,
                                        endCol,
                                };
                                insertList.push(textNode);
                        }

                        siblingsCorrection(insertList);

                        if (parentNode) {
                                parentNode.childNodes = insertList;
                        }

                        nodeList.splice(index, 1, ...insertList);
                }
                if (node.type === 'starttag') {
                        for (const attr of node.attributes) {
                                if (attr.type === 'ps-attr' || attr.value.raw === '' || !hasIgnoreBlock(attr.value.raw, maskChar)) {
                                        continue;
                                }
                                for (const tag of stack) {
                                        const raw = tag.startTag + tag.taggedCode + tag.endTag;
                                        const length = raw.length;

                                        if (attr.value.startOffset <= tag.index && tag.index + length <= attr.value.endOffset) {
                                                const offset = tag.index - attr.value.startOffset;
                                                const above = attr.value.raw.slice(0, offset);
                                                const below = attr.value.raw.slice(offset + length);
                                                attr.value.raw = above + raw + below;
                                                attr.isDynamicValue = true;
                                        }
                                }
                        }
                }
        }

        return nodeList;
}

function snap(str: string, reg: RegExp): [number, string] | [number, string, string, string] {
        const matched = reg.exec(str);
        if (!matched) {
                return [-1, str];
        }
        const index = matched.index;
        const snapPoint = matched[0];
        const above = str.slice(0, index);
        const below = str.slice(index).slice(snapPoint.length);
        return [index, above, snapPoint, below];
}

function removeGlobalOption(reg: RegExp) {
        return new RegExp(reg.source, reg.ignoreCase ? 'i' : '');
}

function prepend(reg: RegExp, str: string) {
        return new RegExp(str + reg.source, reg.ignoreCase ? 'i' : '');
}

function append(reg: RegExp, str: string) {
        return new RegExp(reg.source + str, reg.ignoreCase ? 'i' : '');
}

function hasIgnoreBlock(textContent: string, maskChar: string) {
        return textContent.includes(maskChar);
}

1	import type { Code, IgnoreBlock, IgnoreTag } from './types';
2	import type { MLASTNode, MLASTPreprocessorSpecificBlock, MLASTText } from '@markuplint/ml-ast';
3
4	import { MASK_CHAR } from './const';	1✔
5	import { uuid } from './create-token';	1✔
6	import { sliceFragment } from './get-location';	1✔
7	import { siblingsCorrection } from './siblings-correction';	1✔
8
9	export function ignoreBlock(source: string, tags: IgnoreTag[], maskChar = MASK_CHAR): IgnoreBlock {	1✔
10	let replaced = source;	16✔
11	const stack: Code[] = [];	16✔
12	for (const tag of tags) {	16✔
13	// Replace tags in attributes
14	const attr = maskText(	20✔
15	prepend(tag.start, '(?<=(?:"\|\'))'),
16	append(tag.end, '(?=(?:"\|\'))'),
17	replaced,
18	(startTag, taggedCode, endTag) => {
19	const mask =
20	maskChar.repeat(startTag.length) +	5✔
21	taggedCode.replace(/[^\n]/g, maskChar) +
22	maskChar.repeat((endTag \|\| '').length);	6✔
23	return mask;	5✔
24	},
25	);
26	replaced = attr.replaced;	20✔
27	stack.push(...attr.stack.map(res => ({ ...res, type: tag.type })));	20✔
28
29	// Replace tags in other nodes
30	const text = maskText(tag.start, tag.end, replaced, (startTag, taggedCode, endTag) => {	20✔
31	const mask =
32	maskChar.repeat(startTag.length) +	16✔
33	taggedCode.replace(/[^\n]/g, maskChar) +
34	maskChar.repeat((endTag \|\| '').length);	17✔
35	const taggedMask = `<!${mask.slice(2).slice(0, -1)}>`;	16✔
36	return taggedMask;	16✔
37	});
38	replaced = text.replaced;	20✔
39	stack.push(...text.stack.map(res => ({ ...res, type: tag.type })));	20✔
40	}
41	stack.sort((a, b) => a.index - b.index);	16✔
42
43	return {	16✔
44	source,
45	replaced,
46	stack,
47	maskChar,
48	};
49	}
50
51	function maskText(
52	start: RegExp,
53	end: RegExp,
54	replaced: string,
55	masking: (startTag: string, taggedCode: string, endTag?: string) => string,
56	) {
57	const stack: Omit<Code, 'type'>[] = [];	40✔
58	start = removeGlobalOption(start);	40✔
59	end = removeGlobalOption(end);	40✔
60	while (start.test(replaced)) {	40✔
61	const [index, above, startTag, _below] = snap(replaced, start);	21✔
62	if (!startTag \|\| !_below) {	21!
63	continue;	×
64	}
65	const [, taggedCode, endTag, below] = snap(_below, end);	21✔
66	stack.push({	21✔
67	index,
68	startTag,
69	taggedCode,
70	endTag: endTag \|\| null,	23✔
71	});
72	/**
73	* It will not replace line breaks because detects line number.
74	*/
75	replaced = above + masking(startTag, taggedCode, endTag) + (below \|\| '');	21✔
76	}
77	return {	40✔
78	replaced,
79	stack,
80	};
81	}
82
83	export function restoreNode(nodeList: MLASTNode[], ignoreBlock: IgnoreBlock) {	1✔
84	nodeList = nodeList.slice();	11✔
85	const { source, stack, maskChar } = ignoreBlock;	11✔
86	for (const node of nodeList) {	11✔
87	if (node.type === 'comment' \|\| node.type === 'text' \|\| node.type === 'psblock') {	24✔
88	if (!hasIgnoreBlock(node.raw, maskChar)) {	3!
89	continue;	×
90	}
91	const parentNode = node.parentNode;	3✔
92	const index = nodeList.findIndex(n => n === node);	6✔
93	const insertList: (MLASTText \| MLASTPreprocessorSpecificBlock)[] = [];	3✔
94	let text = node.raw;	3✔
95	let pointer = 0;	3✔
96	for (const tag of stack) {	3✔
97	if (node.startOffset <= tag.index && tag.index < node.endOffset) {	4✔
98	const start = tag.index - node.startOffset;	3✔
99	const body = tag.startTag + tag.taggedCode + (tag.endTag \|\| '');	3!
100	const above = node.raw.slice(pointer, start);	3✔
101	const below = text.slice(above.length + body.length);	3✔
102	if (above) {	3!
103	const offset = node.startOffset + pointer;	×
104	const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(	×
105	source,
106	offset,
107	offset + above.length,
108	);
109	const textNode: MLASTText = {	×
110	...node,
111	uuid: uuid(),
112	type: 'text',
113	raw,
114	startOffset,
115	endOffset,
116	startLine,
117	endLine,
118	startCol,
119	endCol,
120	};
121	if (node.prevNode?.nextNode) {	×
122	node.prevNode.nextNode = textNode;	×
123	}
124	if (node.nextNode?.prevNode) {	×
125	node.nextNode.prevNode = textNode;	×
126	}
127	insertList.push(textNode);	×
128	}
129	if (body) {	3✔
130	const offset = node.startOffset + pointer + above.length;	3✔
131	const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(	3✔
132	source,
133	offset,
134	offset + body.length,
135	);
136	const bodyNode: MLASTPreprocessorSpecificBlock = {	3✔
137	uuid: uuid(),
138	type: 'psblock',
139	nodeName: `#ps:${tag.type}`,
140	raw,
141	parentNode: node.parentNode,
142	prevNode: null,
143	nextNode: null,
144	isFragment: node.isFragment,
145	isGhost: false,
146	startOffset,
147	endOffset,
148	startLine,
149	endLine,
150	startCol,
151	endCol,
152	};
153	if (node.prevNode?.nextNode) {	3!
154	node.prevNode.nextNode = bodyNode;	×
155	}
156	if (node.nextNode?.prevNode) {	3✔
157	node.nextNode.prevNode = bodyNode;	1✔
158	}
159	insertList.push(bodyNode);	3✔
160	}
161	text = below;	3✔
162	pointer = start + body.length;	3✔
163	}
164	}
165	if (text) {	3!
166	const offset = node.endOffset - text.length;	×
167	const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = sliceFragment(	×
168	source,
169	offset,
170	offset + text.length,
171	);
172	const textNode: MLASTText = {	×
173	...node,
174	uuid: uuid(),
175	type: 'text',
176	raw,
177	startOffset,
178	endOffset,
179	startLine,
180	endLine,
181	startCol,
182	endCol,
183	};
184	insertList.push(textNode);	×
185	}
186
187	siblingsCorrection(insertList);	3✔
188
189	if (parentNode) {	3✔
190	parentNode.childNodes = insertList;	3✔
191	}
192
193	nodeList.splice(index, 1, ...insertList);	3✔
194	}
195	if (node.type === 'starttag') {	24✔
196	for (const attr of node.attributes) {	11✔
197	if (attr.type === 'ps-attr' \|\| attr.value.raw === '' \|\| !hasIgnoreBlock(attr.value.raw, maskChar)) {	8!
198	continue;	×
199	}
200	for (const tag of stack) {	8✔
201	const raw = tag.startTag + tag.taggedCode + tag.endTag;	9✔
202	const length = raw.length;	9✔
203
204	if (attr.value.startOffset <= tag.index && tag.index + length <= attr.value.endOffset) {	9✔
205	const offset = tag.index - attr.value.startOffset;	8✔
206	const above = attr.value.raw.slice(0, offset);	8✔
207	const below = attr.value.raw.slice(offset + length);	8✔
208	attr.value.raw = above + raw + below;	8✔
209	attr.isDynamicValue = true;	8✔
210	}
211	}
212	}
213	}
214	}
215
216	return nodeList;	11✔
217	}
218
219	function snap(str: string, reg: RegExp): [number, string] \| [number, string, string, string] {
220	const matched = reg.exec(str);	42✔
221	if (!matched) {	42✔
222	return [-1, str];	2✔
223	}
224	const index = matched.index;	40✔
225	const snapPoint = matched[0];	40✔
226	const above = str.slice(0, index);	40✔
227	const below = str.slice(index).slice(snapPoint.length);	40✔
228	return [index, above, snapPoint, below];	40✔
229	}
230
231	function removeGlobalOption(reg: RegExp) {
232	return new RegExp(reg.source, reg.ignoreCase ? 'i' : '');	80!
233	}
234
235	function prepend(reg: RegExp, str: string) {
236	return new RegExp(str + reg.source, reg.ignoreCase ? 'i' : '');	20!
237	}
238
239	function append(reg: RegExp, str: string) {
240	return new RegExp(reg.source + str, reg.ignoreCase ? 'i' : '');	20!
241	}
242
243	function hasIgnoreBlock(textContent: string, maskChar: string) {
244	return textContent.includes(maskChar);	11✔
245	}

markuplint / markuplint / #2633

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