#582

Build # #582

Build Type

push

Committed by

Commit Message

<a href="https://github.com/markuplint/markuplint/commit/<a class=hub.com/markuplint/markuplint/commit/8b5bf3f38593d150b979edfa46e82d82f7b22a6b">8b5bf3f38<a href="https://github.com/markuplint/markuplint/commit/8b5bf3f38593d150b979edfa46e82d82f7b22a6b">">Merge </a><a class="double-link" href="https://github.com/markuplint/markuplint/commit/<a class="double-link" href="https://github.com/markuplint/markuplint/commit/a19d20f8b3779b6487045d3cd9800410608f76eb">a19d20f8b</a>">a19d20f8b</a><a href="https://github.com/markuplint/markuplint/commit/8b5bf3f38593d150b979edfa46e82d82f7b22a6b"> into 792f22fea">792f22fea</a>

Run Details

2170 of 3256 branches covered (66.65%)

Branch coverage included in aggregate %.

359 of 359 new or added lines in 19 files covered. (100.0%)

3430 of 4757 relevant lines covered (72.1%)

102.42 hits per line

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

90.91

/packages/@markuplint/rules/src/permitted-contents/permitted-content.spec-to-regexp.ts

import {
        ContentModel,
        PermittedContent,
        PermittedContentChoice,
        PermittedContentInterleave,
        PermittedContentOneOrMore,
        PermittedContentOptional,
        PermittedContentRequire,
        PermittedContentZeroOrMore,
        Target,
} from '@markuplint/ml-spec';
import combination from './array.combination';
import { rePCENChar } from '../helpers';
import unfoldContentModelsToTags from './unfold-content-models-to-tags';

const ALL = '(?:<[^>]+>)?';
const ___TRANSPARENT___ = '___TRANSPARENT___';
const ___InTRANSPARENT = '___InTRANSPARENT';
const CUSTOM_ELEMENT = `(?:<[a-z](?:${rePCENChar})*\\-(?:${rePCENChar})*>)`;

export default class ExpGenerator {
        private _idCounter = 0;

        constructor(private _id: number) {}

        public specToRegExp(
                contentRule: PermittedContent[] | boolean,
                parentExp: RegExp | null = null,
                ownNS: string | null = null,
        ) {
                if (contentRule === true) {
                        return new RegExp(`^(?:${ALL})$`);
                }
                if (contentRule === false) {
                        return new RegExp('^$');
                }
                const parentPattern = parentExp ? parentExp.source.replace(/^\^|\$$/g, '') : ALL;
                const pattern = this._toPattern(contentRule, null, ownNS, 1, 1).replace(
                        ___TRANSPARENT___,
                        () => `(?<TRANSPARENT_${this._id}${this._idCounter++}>${parentPattern})`,
                );

                return new RegExp(`^${pattern}$`, 'i');
        }

        private _toPattern(
                contentRule: Target | PermittedContent[],
                ignore: Target | null,
                ownNS: string | null,
                min: number,
                max: number,
        ) {
                if (isTarget(contentRule)) {
                        return this._targetTags(contentRule, ignore, ownNS, min, max);
                }
                let notAllowedDescendantsNamedCapture = '';
                const exp: string[] = [];
                for (const nodeRule of contentRule) {
                        let pattern = '';
                        if (isRequiredContents(nodeRule)) {
                                if (nodeRule.notAllowedDescendants) {
                                        notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants
                                                .map(r => r.replace('#', '_'))
                                                .join('_');
                                        if (nodeRule.require === '#transparent') {
                                                notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                                        }
                                }
                                pattern = this._targetTags(
                                        nodeRule.require,
                                        nodeRule.ignore || null,
                                        ownNS,
                                        nodeRule.min || 1,
                                        nodeRule.max || nodeRule.min || 1,
                                );
                        } else if (isOptionalContents(nodeRule)) {
                                if (nodeRule.notAllowedDescendants) {
                                        notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants
                                                .map(r => r.replace('#', '_'))
                                                .join('_');
                                        if (nodeRule.optional === '#transparent') {
                                                notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                                        }
                                }
                                pattern = this._targetTags(nodeRule.optional, nodeRule.ignore || null, ownNS, 0, nodeRule.max || 1);
                        } else if (isOneOrMoreContents(nodeRule)) {
                                if (nodeRule.notAllowedDescendants) {
                                        notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants
                                                .map(r => r.replace('#', '_'))
                                                .join('_');
                                        if (nodeRule.oneOrMore === '#transparent') {
                                                notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                                        }
                                }
                                pattern = this._toPattern(
                                        nodeRule.oneOrMore,
                                        nodeRule.ignore || null,
                                        ownNS,
                                        1,
                                        nodeRule.max || Infinity,
                                );
                        } else if (isZeroOrMoreContents(nodeRule)) {
                                if (nodeRule.notAllowedDescendants) {
                                        notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants
                                                .map(r => r.replace('#', '_'))
                                                .join('_');
                                        if (nodeRule.zeroOrMore === '#transparent') {
                                                notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;
                                        }
                                }
                                pattern = this._toPattern(
                                        nodeRule.zeroOrMore,
                                        nodeRule.ignore || null,
                                        ownNS,
                                        0,
                                        nodeRule.max || Infinity,
                                );
                        } else if (isChoiceContents(nodeRule)) {
                                pattern = `(?:${nodeRule.choice.map(choice => this._toPattern(choice, null, ownNS, 1, 1)).join('|')})`;
                        } else if (isInterleaveContents(nodeRule)) {
                                pattern = this._interleavePattern(nodeRule.interleave, ownNS);
                        }
                        exp.push(pattern);
                }
                const range = createRange(min, max);
                const c = notAllowedDescendantsNamedCapture
                        ? `?<NAD_${this._id}${this._idCounter++}_${notAllowedDescendantsNamedCapture}>`
                        : '?:';
                if (1 === exp.length && range === '') {
                        if (notAllowedDescendantsNamedCapture) {
                                return `(${c}${exp[0]})`;
                        }
                        return exp[0];
                }
                if (range === '') {
                        if (notAllowedDescendantsNamedCapture) {
                                return `(${c}${exp.join('')})`;
                        }
                        return exp.join('');
                }
                return `(${c}${exp.join('')})${range}`;
        }

        private _interleavePattern(contents: PermittedContent[][], ownNS: string | null) {
                const interleave = contents.map(content => this._toPattern(content, null, ownNS, 1, 1));
                const patterns = combination(interleave).map((pattern, i) =>
                        pattern.join('').replace(/(\(\?<[A-Z]+_)([0-9]+)_/g, ($0, $1, $2) => `${$1}${$2}${i}_`),
                );
                return join(patterns);
        }

        private _targetTags(target: Target, ignore: Target | null, ownNS: string | null, min: number, max: number) {
                const tagList = this._resolveTags(target, ownNS);
                const ignoreList = ignore ? this._resolveTags(ignore, ownNS) : null;

                if (ignoreList) {
                        ignoreList.forEach(ignore => tagList.delete(ignore));
                }

                return join(Array.from(tagList), createRange(min, max));
        }

        private _resolveTags(target: Target, ownNS: string | null) {
                const list = Array.isArray(target) ? target : [target];
                const tagList = new TagList();

                for (const name of list) {
                        if (name !== '#text' && name[0] === '#') {
                                switch (name) {
                                        case '#transparent': {
                                                tagList.addPattern(___TRANSPARENT___);
                                                break;
                                        }
                                        case '#custom': {
                                                tagList.addPattern(CUSTOM_ELEMENT);
                                                break;
                                        }
                                        default: {
                                                const selectors = unfoldContentModelsToTags(name as ContentModel);
                                                const counter = this._idCounter++;
                                                selectors.forEach(selector => {
                                                        if (selector === '#custom') {
                                                                tagList.addPattern(CUSTOM_ELEMENT);
                                                                return;
                                                        }
                                                        if (/]$/i.test(selector)) {
                                                                const [, tagName] = /^([^[\]]+)\[[^\]]+\]$/.exec(selector) || [];
                                                                // ACM = Attributes by content model
                                                                const exp = `(?<ACM_${this._id}${counter}_${name.slice(1)}_${tagName}><${tagName}>)`;
                                                                tagList.addPattern(exp);
                                                                return;
                                                        }
                                                        tagList.addTag(selector, ownNS);
                                                });
                                        }
                                }
                                continue;
                        }
                        tagList.addTag(name, ownNS);
                }

                return tagList.result();
        }
}

class TagList {
        #list = new Set<string>();

        addPattern(pattern: string) {
                this.#list.add(pattern);
        }

        addTag(tagNameOrSelector: string, ownNS: string | null) {
                if (ownNS) {
                        tagNameOrSelector = tagNameOrSelector.replace(new RegExp(`^${ownNS}:`, 'i'), '');
                }
                this.#list.add(`<${tagNameOrSelector}>`);
        }

        result() {
                return this.#list;
        }
}

function isRequiredContents(contents: PermittedContent): contents is PermittedContentRequire {
        return 'require' in contents;
}

function isOptionalContents(contents: PermittedContent): contents is PermittedContentOptional {
        return 'optional' in contents;
}

function isOneOrMoreContents(contents: PermittedContent): contents is PermittedContentOneOrMore {
        return 'oneOrMore' in contents;
}

function isZeroOrMoreContents(contents: PermittedContent): contents is PermittedContentZeroOrMore {
        return 'zeroOrMore' in contents;
}

function isChoiceContents(contents: PermittedContent): contents is PermittedContentChoice {
        return 'choice' in contents;
}

function isInterleaveContents(contents: PermittedContent): contents is PermittedContentInterleave {
        return 'interleave' in contents;
}

function createRange(min: number, max: number) {
        let result = `{${min},${max}}`;
        switch (result) {
                case '{0,1}':
                        result = '?';
                        break;
                case '{1,1}':
                        result = '';
                        break;
                case '{0,Infinity}':
                        result = '*';
                        break;
                case '{1,Infinity}':
                        result = '+';
                        break;
        }
        return result;
}

function isTarget(contentRule: Target | PermittedContent[]): contentRule is Target {
        if (typeof contentRule === 'string') {
                return true;
        }
        return contentRule.some((i: string | PermittedContent) => typeof i === 'string');
}

function join(pattern: string[], range = '') {
        if (1 === pattern.length && range === '') {
                return pattern[0];
        }
        return `(?:${pattern.join('|')})${range}`;
}

1	import {
2	ContentModel,
3	PermittedContent,
4	PermittedContentChoice,
5	PermittedContentInterleave,
6	PermittedContentOneOrMore,
7	PermittedContentOptional,
8	PermittedContentRequire,
9	PermittedContentZeroOrMore,
10	Target,
11	} from '@markuplint/ml-spec';
12	import combination from './array.combination';	2✔
13	import { rePCENChar } from '../helpers';	2✔
14	import unfoldContentModelsToTags from './unfold-content-models-to-tags';	2✔
15
16	const ALL = '(?:<[^>]+>)?';	2✔
17	const ___TRANSPARENT___ = '___TRANSPARENT___';	2✔
18	const ___InTRANSPARENT = '___InTRANSPARENT';	2✔
19	const CUSTOM_ELEMENT = `(?:<[a-z](?:${rePCENChar})\\-(?:${rePCENChar})>)`;	2✔
20
21	export default class ExpGenerator {	2✔
22	private _idCounter = 0;	244✔
23
24	constructor(private _id: number) {}	244✔
25
26	public specToRegExp(
27	contentRule: PermittedContent[] \| boolean,
28	parentExp: RegExp \| null = null,	24✔
29	ownNS: string \| null = null,	25✔
30	) {
31	if (contentRule === true) {	223✔
32	return new RegExp(`^(?:${ALL})$`);	7✔
33	}
34	if (contentRule === false) {	216✔
35	return new RegExp('^$');	10✔
36	}
37	const parentPattern = parentExp ? parentExp.source.replace(/^\^\|\$$/g, '') : ALL;	206✔
38	const pattern = this._toPattern(contentRule, null, ownNS, 1, 1).replace(	206✔
39	___TRANSPARENT___,
40	() => `(?<TRANSPARENT_${this._id}${this._idCounter++}>${parentPattern})`,	34✔
41	);
42
43	return new RegExp(`^${pattern}$`, 'i');	206✔
44	}
45
46	private _toPattern(
47	contentRule: Target \| PermittedContent[],
48	ignore: Target \| null,
49	ownNS: string \| null,
50	min: number,
51	max: number,
52	) {
53	if (isTarget(contentRule)) {	578✔
54	return this._targetTags(contentRule, ignore, ownNS, min, max);	311✔
55	}
56	let notAllowedDescendantsNamedCapture = '';	267✔
57	const exp: string[] = [];	267✔
58	for (const nodeRule of contentRule) {	267✔
59	let pattern = '';	427✔
60	if (isRequiredContents(nodeRule)) {	427✔
61	if (nodeRule.notAllowedDescendants) {	53✔
62	notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants	4✔
63	.map(r => r.replace('#', '_'))	4✔
64	.join('_');
65	if (nodeRule.require === '#transparent') {	4!
66	notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;	×
67	}
68	}
69	pattern = this._targetTags(	53✔
70	nodeRule.require,
71	nodeRule.ignore \|\| null,	105✔
72	ownNS,
73	nodeRule.min \|\| 1,	99✔
74	nodeRule.max \|\| nodeRule.min \|\| 1,	144✔
75	);
76	} else if (isOptionalContents(nodeRule)) {	374✔
77	if (nodeRule.notAllowedDescendants) {	22!
78	notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants	×
79	.map(r => r.replace('#', '_'))	×
80	.join('_');
81	if (nodeRule.optional === '#transparent') {	×
82	notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;	×
83	}
84	}
85	pattern = this._targetTags(nodeRule.optional, nodeRule.ignore \|\| null, ownNS, 0, nodeRule.max \|\| 1);	22✔
86	} else if (isOneOrMoreContents(nodeRule)) {	352✔
87	if (nodeRule.notAllowedDescendants) {	75!
88	notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants	×
89	.map(r => r.replace('#', '_'))	×
90	.join('_');
91	if (nodeRule.oneOrMore === '#transparent') {	×
92	notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;	×
93	}
94	}
95	pattern = this._toPattern(	75✔
96	nodeRule.oneOrMore,
97	nodeRule.ignore \|\| null,	150✔
98	ownNS,
99	1,
100	nodeRule.max \|\| Infinity,	150✔
101	);
102	} else if (isZeroOrMoreContents(nodeRule)) {	277✔
103	if (nodeRule.notAllowedDescendants) {	259✔
104	notAllowedDescendantsNamedCapture = nodeRule.notAllowedDescendants	33✔
105	.map(r => r.replace('#', '_'))	63✔
106	.join('_');
107	if (nodeRule.zeroOrMore === '#transparent') {	33✔
108	notAllowedDescendantsNamedCapture += `${___InTRANSPARENT}`;	20✔
109	}
110	}
111	pattern = this._toPattern(	259✔
112	nodeRule.zeroOrMore,
113	nodeRule.ignore \|\| null,	506✔
114	ownNS,
115	0,
116	nodeRule.max \|\| Infinity,	518✔
117	);
118	} else if (isChoiceContents(nodeRule)) {	18✔
119	pattern = `(?:${nodeRule.choice.map(choice => this._toPattern(choice, null, ownNS, 1, 1)).join('\|')})`;	33✔
120	} else if (isInterleaveContents(nodeRule)) {	2!
121	pattern = this._interleavePattern(nodeRule.interleave, ownNS);	2✔
122	}
123	exp.push(pattern);	427✔
124	}
125	const range = createRange(min, max);	267✔
126	const c = notAllowedDescendantsNamedCapture	267✔
127	? `?<NAD_${this._id}${this._idCounter++}_${notAllowedDescendantsNamedCapture}>`	267✔
128	: '?:';
129	if (1 === exp.length && range === '') {	267✔
130	if (notAllowedDescendantsNamedCapture) {	212✔
131	return `(${c}${exp[0]})`;	26✔
132	}
133	return exp[0];	186✔
134	}
135	if (range === '') {	55✔
136	if (notAllowedDescendantsNamedCapture) {	32✔
137	return `(${c}${exp.join('')})`;	7✔
138	}
139	return exp.join('');	25✔
140	}
141	return `(${c}${exp.join('')})${range}`;	23✔
142	}
143
144	private _interleavePattern(contents: PermittedContent[][], ownNS: string \| null) {
145	const interleave = contents.map(content => this._toPattern(content, null, ownNS, 1, 1));	5✔
146	const patterns = combination(interleave).map((pattern, i) =>	2✔
147	pattern.join('').replace(/(\(\?<[A-Z]+_)([0-9]+)_/g, ($0, $1, $2) => `${$1}${$2}${i}_`),	8✔
148	);
149	return join(patterns);	2✔
150	}
151
152	private _targetTags(target: Target, ignore: Target \| null, ownNS: string \| null, min: number, max: number) {
153	const tagList = this._resolveTags(target, ownNS);	386✔
154	const ignoreList = ignore ? this._resolveTags(ignore, ownNS) : null;	386✔
155
156	if (ignoreList) {	386✔
157	ignoreList.forEach(ignore => tagList.delete(ignore));	13✔
158	}
159
160	return join(Array.from(tagList), createRange(min, max));	386✔
161	}
162
163	private _resolveTags(target: Target, ownNS: string \| null) {
164	const list = Array.isArray(target) ? target : [target];	399✔
165	const tagList = new TagList();	399✔
166
167	for (const name of list) {	399✔
168	if (name !== '#text' && name[0] === '#') {	652✔
169	switch (name) {	287✔
170	case '#transparent': {	287!
171	tagList.addPattern(___TRANSPARENT___);	34✔
172	break;	34✔
173	}
174	case '#custom': {
175	tagList.addPattern(CUSTOM_ELEMENT);	×
176	break;	×
177	}
178	default: {
179	const selectors = unfoldContentModelsToTags(name as ContentModel);	253✔
180	const counter = this._idCounter++;	253✔
181	selectors.forEach(selector => {	253✔
182	if (selector === '#custom') {	8,020✔
183	tagList.addPattern(CUSTOM_ELEMENT);	90✔
184	return;	90✔
185	}
186	if (/]$/i.test(selector)) {	7,930✔
187	const [, tagName] = /^([^[\]]+)\[[^\]]+\]$/.exec(selector) \|\| [];	900!
188	// ACM = Attributes by content model
189	const exp = `(?<ACM_${this._id}${counter}_${name.slice(1)}_${tagName}><${tagName}>)`;	900✔
190	tagList.addPattern(exp);	900✔
191	return;	900✔
192	}
193	tagList.addTag(selector, ownNS);	7,030✔
194	});
195	}
196	}
197	continue;	287✔
198	}
199	tagList.addTag(name, ownNS);	365✔
200	}
201
202	return tagList.result();	399✔
203	}
204	}
205
206	class TagList {
207	#list = new Set<string>();	399✔
208
209	addPattern(pattern: string) {
210	this.#list.add(pattern);	1,024✔
211	}
212
213	addTag(tagNameOrSelector: string, ownNS: string \| null) {
214	if (ownNS) {	7,395✔
215	tagNameOrSelector = tagNameOrSelector.replace(new RegExp(`^${ownNS}:`, 'i'), '');	6,997✔
216	}
217	this.#list.add(`<${tagNameOrSelector}>`);	7,395✔
218	}
219
220	result() {
221	return this.#list;	399✔
222	}
223	}
224
225	function isRequiredContents(contents: PermittedContent): contents is PermittedContentRequire {
226	return 'require' in contents;	427✔
227	}
228
229	function isOptionalContents(contents: PermittedContent): contents is PermittedContentOptional {
230	return 'optional' in contents;	374✔
231	}
232
233	function isOneOrMoreContents(contents: PermittedContent): contents is PermittedContentOneOrMore {
234	return 'oneOrMore' in contents;	352✔
235	}
236
237	function isZeroOrMoreContents(contents: PermittedContent): contents is PermittedContentZeroOrMore {
238	return 'zeroOrMore' in contents;	277✔
239	}
240
241	function isChoiceContents(contents: PermittedContent): contents is PermittedContentChoice {
242	return 'choice' in contents;	18✔
243	}
244
245	function isInterleaveContents(contents: PermittedContent): contents is PermittedContentInterleave {
246	return 'interleave' in contents;	2✔
247	}
248
249	function createRange(min: number, max: number) {
250	let result = `{${min},${max}}`;	653✔
251	switch (result) {	653✔
252	case '{0,1}':	645✔
253	result = '?';	22✔
254	break;	22✔
255	case '{1,1}':
256	result = '';	289✔
257	break;	289✔
258	case '{0,Infinity}':
259	result = '*';	259✔
260	break;	259✔
261	case '{1,Infinity}':
262	result = '+';	75✔
263	break;	75✔
264	}
265	return result;	653✔
266	}
267
268	function isTarget(contentRule: Target \| PermittedContent[]): contentRule is Target {
269	if (typeof contentRule === 'string') {	578✔
270	return true;	274✔
271	}
272	return contentRule.some((i: string \| PermittedContent) => typeof i === 'string');	464✔
273	}
274
275	function join(pattern: string[], range = '') {	2✔
276	if (1 === pattern.length && range === '') {	388✔
277	return pattern[0];	36✔
278	}
279	return `(?:${pattern.join('\|')})${range}`;	352✔
280	}

markuplint / markuplint / #582

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