1311086680

Build Type

github

Committed by GitHub

Commit Message

Merge c38d71091 into 604e7b22b

Pull Request Pull Request #424: Jscodegen unit test support

Run Details

4796 of 5158 branches covered (92.98%)

Branch coverage included in aggregate %.

23 of 24 new or added lines in 4 files covered. (95.83%)

3 existing lines in 1 file now uncovered.

9487 of 9725 relevant lines covered (97.55%)

5724008.83 hits per line

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

95.45

/src/jsCodegen/emitTest.ts

import { NODE_TYPES } from '../domFacade/ConcreteNode';
import QName from '../expressions/dataTypes/valueTypes/QName';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import escapeJavaScriptString from './escapeJavaScriptString';
import {
        acceptAst,
        CompiledResultType,
        ContextItemIdentifier,
        GeneratedCodeBaseType,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';

const testAstNodes = {
        TEXT_TEST: 'textTest',
        ELEMENT_TEST: 'elementTest',
        NAME_TEST: 'nameTest',
        WILDCARD: 'Wildcard',
};

export const tests = Object.values(testAstNodes);

// text() matches any text node.
// https://www.w3.org/TR/xpath-31/#doc-xpath31-TextTest
function emitTextTest(
        _ast: IAST,
        identifier: ContextItemIdentifier
): [PartialCompilationResult, string | null] {
        return [
                acceptAst(`${identifier}.nodeType === /*TEXT_NODE*/ ${NODE_TYPES.TEXT_NODE}`, {
                        type: GeneratedCodeBaseType.Value,
                }),
                null,
        ];
}

function resolveNamespaceURI(qName: QName, staticContext: CodeGenContext) {
        // Resolve prefix.
        if (qName.namespaceURI === null && qName.prefix !== '*') {
                qName.namespaceURI = staticContext.resolveNamespace(qName.prefix || '') || null;
                if (!qName.namespaceURI && qName.prefix) {
                        throw new Error(`XPST0081: The prefix ${qName.prefix} could not be resolved.`);
                }
        }
}

function emitNameTestFromQName(
        identifier: ContextItemIdentifier,
        qName: QName,
        staticContext: CodeGenContext
): [PartialCompilationResult, string | null] {
        const namespaceURIWasResolved = qName.namespaceURI === null;
        resolveNamespaceURI(qName, staticContext);
        const { prefix, namespaceURI, localName } = qName;

        const isElementOrAttributeCode = `${identifier}.nodeType
                && (${identifier}.nodeType === /*ELEMENT_NODE*/ ${NODE_TYPES.ELEMENT_NODE}
                || ${identifier}.nodeType === /*ATTRIBUTE_NODE*/ ${NODE_TYPES.ATTRIBUTE_NODE})`;

        // Simple cases.
        if (prefix === '*') {
                if (localName === '*') {
                        return [
                                acceptAst(isElementOrAttributeCode, { type: GeneratedCodeBaseType.Value }),
                                null,
                        ];
                }
                return [
                        acceptAst(
                                `${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(
                                        localName
                                )}`,
                                { type: GeneratedCodeBaseType.Value }
                        ),
                        `name-${localName}`,
                ];
        }

        // Return condition comparing localName and namespaceURI against the context
        // item.
        const matchesLocalNameCode =
                localName !== '*'
                        ? `${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(
                                        localName
                          )} && `
                        : '';

        let resolveNamespaceURICode: string;
        if (namespaceURIWasResolved && !prefix) {
                // This prefix came from the name
                // While the namespaceuri is also present, this should not be used for _attribute_ name tests
                resolveNamespaceURICode = `${identifier}.nodeType
&& ${identifier}.nodeType === /*ELEMENT_NODE*/ ${
                        NODE_TYPES.ELEMENT_NODE
                } ? ${escapeJavaScriptString(namespaceURI)} : null`;
        } else {
                // There was a prefix. This applies to elements and attributes
                resolveNamespaceURICode = escapeJavaScriptString(namespaceURI);
        }
        const matchesNamespaceCode = `(${identifier}.namespaceURI || null) === (${resolveNamespaceURICode} || null)`;

        return [
                acceptAst(`${matchesLocalNameCode}${matchesNamespaceCode}`, {
                        type: GeneratedCodeBaseType.Value,
                }),
                `name-${localName}`,
        ];
}

// element() and element(*) match any single element node, regardless of its name or type annotation.
// https://www.w3.org/TR/xpath-31/#doc-xpath31-ElementTest
function emitElementTest(
        ast: IAST,
        identifier: ContextItemIdentifier,
        staticContext: CodeGenContext
): [PartialCompilationResult, string | null] {
        const elementName = astHelper.getFirstChild(ast, 'elementName');
        const star = elementName && astHelper.getFirstChild(elementName, 'star');
        const isElementCode = `${identifier}.nodeType === /*ELEMENT_NODE*/ ${NODE_TYPES.ELEMENT_NODE}`;

        if (elementName === null || star) {
                return [acceptAst(isElementCode, { type: GeneratedCodeBaseType.Value }), null];
        }

        const qName = astHelper.getQName(astHelper.getFirstChild(elementName, 'QName'));

        return emitNameTestFromQName(identifier, qName, staticContext);
}

// A node test that consists only of an EQName or a Wildcard is called a name test.
// https://www.w3.org/TR/xpath-31/#doc-xpath31-NameTest
function emitNameTest(ast: IAST, identifier: ContextItemIdentifier, staticContext: CodeGenContext) {
        return emitNameTestFromQName(identifier, astHelper.getQName(ast), staticContext);
}

// select all element children of the context node
// for example: child::*.
// https://www.w3.org/TR/xpath-31/#doc-xpath31-Wildcard
function emitWildcard(
        ast: IAST,
        identifier: ContextItemIdentifier,
        staticContext: CodeGenContext
): [PartialCompilationResult, string | null] {
        if (!astHelper.getFirstChild(ast, 'star')) {
                return emitNameTestFromQName(
                        identifier,
                        {
                                localName: '*',
                                namespaceURI: null,
                                prefix: '*',
                        },
                        staticContext
                );
        }

        const uri = astHelper.getFirstChild(ast, 'uri');
        if (uri) {
                return emitNameTestFromQName(
                        identifier,
                        {
                                localName: '*',
                                namespaceURI: astHelper.getTextContent(uri),
                                prefix: '',
                        },
                        staticContext
                );
        }

        // Either the prefix or the localName are 'starred', find out which one
        const ncName = astHelper.getFirstChild(ast, 'NCName');
        if (astHelper.getFirstChild(ast, '*')[0] === 'star') {
                // The prefix is 'starred'
                return emitNameTestFromQName(
                        identifier,
                        {
                                localName: astHelper.getTextContent(ncName),
                                namespaceURI: null,
                                prefix: '*',
                        },
                        staticContext
                );
        }

        // The localName is 'starred'
        return emitNameTestFromQName(
                identifier,
                {
                        localName: '*',
                        namespaceURI: null,
                        prefix: astHelper.getTextContent(ncName),
                },
                staticContext
        );
}

export default function emitTest(
        ast: IAST,
        identifier: ContextItemIdentifier,
        staticContext: CodeGenContext
): [PartialCompilationResult, string | null] {
        // emitTest returns a tuple of the generated code and an optional bucket.

        const test = ast[0];

        switch (test) {
                case testAstNodes.ELEMENT_TEST:
                        return emitElementTest(ast, identifier, staticContext);
                case testAstNodes.TEXT_TEST:
                        return emitTextTest(ast, identifier);
                case testAstNodes.NAME_TEST:
                        return emitNameTest(ast, identifier, staticContext);
                case testAstNodes.WILDCARD:
                        return emitWildcard(ast, identifier, staticContext);
                default:
                        return [rejectAst(`Unsupported: the test '${test}'.`), null];
        }
}

1	import { NODE_TYPES } from '../domFacade/ConcreteNode';
2	import QName from '../expressions/dataTypes/valueTypes/QName';
3	import astHelper, { IAST } from '../parsing/astHelper';	18✔
4	import { CodeGenContext } from './CodeGenContext';
5	import escapeJavaScriptString from './escapeJavaScriptString';	18✔
6	import {	18✔
7	acceptAst,
8	CompiledResultType,
9	ContextItemIdentifier,
10	GeneratedCodeBaseType,
11	PartialCompilationResult,
12	rejectAst,
13	} from './JavaScriptCompiledXPath';
14
15	const testAstNodes = {	18✔
16	TEXT_TEST: 'textTest',
17	ELEMENT_TEST: 'elementTest',
18	NAME_TEST: 'nameTest',
19	WILDCARD: 'Wildcard',
20	};
21
22	export const tests = Object.values(testAstNodes);	18✔
23
24	// text() matches any text node.
25	// https://www.w3.org/TR/xpath-31/#doc-xpath31-TextTest
26	function emitTextTest(
27	_ast: IAST,
28	identifier: ContextItemIdentifier
29	): [PartialCompilationResult, string \| null] {
30	return [	75✔
31	acceptAst(`${identifier}.nodeType === /TEXT_NODE/ ${NODE_TYPES.TEXT_NODE}`, {
32	type: GeneratedCodeBaseType.Value,
33	}),
34	null,
35	];
36	}
37
38	function resolveNamespaceURI(qName: QName, staticContext: CodeGenContext) {
39	// Resolve prefix.
40	if (qName.namespaceURI === null && qName.prefix !== '*') {	2,199✔
41	qName.namespaceURI = staticContext.resolveNamespace(qName.prefix \|\| '') \|\| null;	1,686✔
42	if (!qName.namespaceURI && qName.prefix) {	1,686✔
43	throw new Error(`XPST0081: The prefix ${qName.prefix} could not be resolved.`);	96✔
44	}
45	}
46	}
47
48	function emitNameTestFromQName(
49	identifier: ContextItemIdentifier,
50	qName: QName,
51	staticContext: CodeGenContext
52	): [PartialCompilationResult, string \| null] {
53	const namespaceURIWasResolved = qName.namespaceURI === null;	2,199✔
54	resolveNamespaceURI(qName, staticContext);	2,199✔
55	const { prefix, namespaceURI, localName } = qName;	2,103✔
56
57	const isElementOrAttributeCode = `${identifier}.nodeType	2,103✔
58	&& (${identifier}.nodeType === /ELEMENT_NODE/ ${NODE_TYPES.ELEMENT_NODE}
59	\|\| ${identifier}.nodeType === /ATTRIBUTE_NODE/ ${NODE_TYPES.ATTRIBUTE_NODE})`;
60
61	// Simple cases.
62	if (prefix === '*') {	2,103✔
63	if (localName === '*') {	477✔
64	return [	444✔
65	acceptAst(isElementOrAttributeCode, { type: GeneratedCodeBaseType.Value }),
66	null,
67	];
68	}
69	return [	33✔
70	acceptAst(
71	`${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(
72	localName
73	)}`,
74	{ type: GeneratedCodeBaseType.Value }
75	),
76	`name-${localName}`,
77	];
78	}
79
80	// Return condition comparing localName and namespaceURI against the context
81	// item.
82	const matchesLocalNameCode =
83	localName !== '*'	1,626✔
84	? `${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(	1,626✔
85	localName
86	)} && `
87	: '';
88
89	let resolveNamespaceURICode: string;
90	if (namespaceURIWasResolved && !prefix) {	1,626✔
91	// This prefix came from the name
92	// While the namespaceuri is also present, this should not be used for _attribute_ name tests
93	resolveNamespaceURICode = `${identifier}.nodeType	1,572✔
94	&& ${identifier}.nodeType === /ELEMENT_NODE/ ${
95	NODE_TYPES.ELEMENT_NODE
96	} ? ${escapeJavaScriptString(namespaceURI)} : null`;
97	} else {
98	// There was a prefix. This applies to elements and attributes
99	resolveNamespaceURICode = escapeJavaScriptString(namespaceURI);	54✔
100	}
101	const matchesNamespaceCode = `(${identifier}.namespaceURI \|\| null) === (${resolveNamespaceURICode} \|\| null)`;	1,626✔
102
103	return [	1,626✔
104	acceptAst(`${matchesLocalNameCode}${matchesNamespaceCode}`, {
105	type: GeneratedCodeBaseType.Value,
106	}),
107	`name-${localName}`,
108	];
109	}
110
111	// element() and element(*) match any single element node, regardless of its name or type annotation.
112	// https://www.w3.org/TR/xpath-31/#doc-xpath31-ElementTest
113	function emitElementTest(
114	ast: IAST,
115	identifier: ContextItemIdentifier,
116	staticContext: CodeGenContext
117	): [PartialCompilationResult, string \| null] {
118	const elementName = astHelper.getFirstChild(ast, 'elementName');	123✔
119	const star = elementName && astHelper.getFirstChild(elementName, 'star');	123✔
120	const isElementCode = `${identifier}.nodeType === /ELEMENT_NODE/ ${NODE_TYPES.ELEMENT_NODE}`;	123✔
121
122	if (elementName === null \|\| star) {	123✔
123	return [acceptAst(isElementCode, { type: GeneratedCodeBaseType.Value }), null];	51✔
124	}
125
126	const qName = astHelper.getQName(astHelper.getFirstChild(elementName, 'QName'));	72✔
127
128	return emitNameTestFromQName(identifier, qName, staticContext);	72✔
129	}
130
131	// A node test that consists only of an EQName or a Wildcard is called a name test.
132	// https://www.w3.org/TR/xpath-31/#doc-xpath31-NameTest
133	function emitNameTest(ast: IAST, identifier: ContextItemIdentifier, staticContext: CodeGenContext) {
134	return emitNameTestFromQName(identifier, astHelper.getQName(ast), staticContext);	1,587✔
135	}
136
137	// select all element children of the context node
138	// for example: child::*.
139	// https://www.w3.org/TR/xpath-31/#doc-xpath31-Wildcard
140	function emitWildcard(
141	ast: IAST,
142	identifier: ContextItemIdentifier,
143	staticContext: CodeGenContext
144	): [PartialCompilationResult, string \| null] {
145	if (!astHelper.getFirstChild(ast, 'star')) {	540✔
146	return emitNameTestFromQName(	444✔
147	identifier,
148	{
149	localName: '*',
150	namespaceURI: null,
151	prefix: '*',
152	},
153	staticContext
154	);
155	}
156
157	const uri = astHelper.getFirstChild(ast, 'uri');	96✔
158	if (uri) {	96!
159	return emitNameTestFromQName(	×
160	identifier,
161	{
162	localName: '*',
163	namespaceURI: astHelper.getTextContent(uri),
164	prefix: '',
165	},
166	staticContext
167	);
168	}
169
170	// Either the prefix or the localName are 'starred', find out which one
171	const ncName = astHelper.getFirstChild(ast, 'NCName');	96✔
172	if (astHelper.getFirstChild(ast, '*')[0] === 'star') {	96✔
173	// The prefix is 'starred'
174	return emitNameTestFromQName(	33✔
175	identifier,
176	{
177	localName: astHelper.getTextContent(ncName),
178	namespaceURI: null,
179	prefix: '*',
180	},
181	staticContext
182	);
183	}
184
185	// The localName is 'starred'
186	return emitNameTestFromQName(	63✔
187	identifier,
188	{
189	localName: '*',
190	namespaceURI: null,
191	prefix: astHelper.getTextContent(ncName),
192	},
193	staticContext
194	);
195	}
196
197	export default function emitTest(	18✔
198	ast: IAST,
199	identifier: ContextItemIdentifier,
200	staticContext: CodeGenContext
201	): [PartialCompilationResult, string \| null] {
202	// emitTest returns a tuple of the generated code and an optional bucket.
203
204	const test = ast[0];	2,325✔
205
206	switch (test) {	2,325✔
207	case testAstNodes.ELEMENT_TEST:	2,325!
208	return emitElementTest(ast, identifier, staticContext);	123✔
209	case testAstNodes.TEXT_TEST:
210	return emitTextTest(ast, identifier);	75✔
211	case testAstNodes.NAME_TEST:
212	return emitNameTest(ast, identifier, staticContext);	1,587✔
213	case testAstNodes.WILDCARD:
214	return emitWildcard(ast, identifier, staticContext);	540✔
215	default:
NEW 216	return [rejectAst(`Unsupported: the test '${test}'.`), null];	×
217	}
218	}

FontoXML / fontoxpath / 1311086680

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