1216892494

Build Type

github

Committed by GitHub

Commit Message

Merge 33268a108 into 00a67eead

Pull Request Pull Request #418: Fix annotation in the built version of fontoxpath being skipped

Run Details

4747 of 5106 branches covered (92.97%)

Branch coverage included in aggregate %.

106 of 106 new or added lines in 6 files covered. (100.0%)

5 existing lines in 2 files now uncovered.

9434 of 9669 relevant lines covered (97.57%)

5605714.64 hits per line

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

95.24

/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 {
        return acceptAst(`${identifier}.nodeType === /*TEXT_NODE*/ ${NODE_TYPES.TEXT_NODE}`, {
                type: GeneratedCodeBaseType.Value,
        });
}

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 {
        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 });
                }
                return acceptAst(
                        `${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(
                                localName
                        )}`,
                        { type: GeneratedCodeBaseType.Value }
                );
        }

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

        const isElementConditionCode = `${identifier}.nodeType && ${identifier}.nodeType === /*ELEMENT_NODE*/ ${NODE_TYPES.ELEMENT_NODE}`;
        const resolveNamespaceURICode =
                prefix === ''
                        ? `(${isElementConditionCode} ? ${escapeJavaScriptString(namespaceURI)} : null)`
                        : escapeJavaScriptString(namespaceURI);
        const matchesNamespaceCode = `(${identifier}.namespaceURI || null) === (${resolveNamespaceURICode} || null)`;

        return acceptAst(`${matchesLocalNameCode}${matchesNamespaceCode}`, {
                type: GeneratedCodeBaseType.Value,
        });
}

// 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 {
        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 });
        }

        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 {
        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 {
        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}'.`);
        }
}

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(_ast: IAST, identifier: ContextItemIdentifier): PartialCompilationResult {
27	return acceptAst(`${identifier}.nodeType === /TEXT_NODE/ ${NODE_TYPES.TEXT_NODE}`, {	75✔
28	type: GeneratedCodeBaseType.Value,
29	});
30	}
31
32	function resolveNamespaceURI(qName: QName, staticContext: CodeGenContext) {
33	// Resolve prefix.
34	if (qName.namespaceURI === null && qName.prefix !== '*') {	2,181✔
35	qName.namespaceURI = staticContext.resolveNamespace(qName.prefix \|\| '') \|\| null;	1,677✔
36	if (!qName.namespaceURI && qName.prefix) {	1,677✔
37	throw new Error(`XPST0081: The prefix ${qName.prefix} could not be resolved.`);	96✔
38	}
39	}
40	}
41
42	function emitNameTestFromQName(
43	identifier: ContextItemIdentifier,
44	qName: QName,
45	staticContext: CodeGenContext
46	): PartialCompilationResult {
47	resolveNamespaceURI(qName, staticContext);	2,181✔
48	const { prefix, namespaceURI, localName } = qName;	2,085✔
49
50	const isElementOrAttributeCode = `${identifier}.nodeType	2,085✔
51	&& (${identifier}.nodeType === /ELEMENT_NODE/ ${NODE_TYPES.ELEMENT_NODE}
52	\|\| ${identifier}.nodeType === /ATTRIBUTE_NODE/ ${NODE_TYPES.ATTRIBUTE_NODE})`;
53
54	// Simple cases.
55	if (prefix === '*') {	2,085✔
56	if (localName === '*') {	477✔
57	return acceptAst(isElementOrAttributeCode, { type: GeneratedCodeBaseType.Value });	444✔
58	}
59	return acceptAst(	33✔
60	`${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(
61	localName
62	)}`,
63	{ type: GeneratedCodeBaseType.Value }
64	);
65	}
66
67	// Return condition comparing localName and namespaceURI against the context
68	// item.
69	const matchesLocalNameCode =
70	localName !== '*'	1,608✔
71	? `${isElementOrAttributeCode} && ${identifier}.localName === ${escapeJavaScriptString(	1,608✔
72	localName
73	)} && `
74	: '';
75
76	const isElementConditionCode = `${identifier}.nodeType && ${identifier}.nodeType === /ELEMENT_NODE/ ${NODE_TYPES.ELEMENT_NODE}`;	1,608✔
77	const resolveNamespaceURICode =
78	prefix === ''	1,608✔
79	? `(${isElementConditionCode} ? ${escapeJavaScriptString(namespaceURI)} : null)`	1,608✔
80	: escapeJavaScriptString(namespaceURI);
81	const matchesNamespaceCode = `(${identifier}.namespaceURI \|\| null) === (${resolveNamespaceURICode} \|\| null)`;	1,608✔
82
83	return acceptAst(`${matchesLocalNameCode}${matchesNamespaceCode}`, {	1,608✔
84	type: GeneratedCodeBaseType.Value,
85	});
86	}
87
88	// element() and element(*) match any single element node, regardless of its name or type annotation.
89	// https://www.w3.org/TR/xpath-31/#doc-xpath31-ElementTest
90	function emitElementTest(
91	ast: IAST,
92	identifier: ContextItemIdentifier,
93	staticContext: CodeGenContext
94	): PartialCompilationResult {
95	const elementName = astHelper.getFirstChild(ast, 'elementName');	123✔
96	const star = elementName && astHelper.getFirstChild(elementName, 'star');	123✔
97	const isElementCode = `${identifier}.nodeType === /ELEMENT_NODE/ ${NODE_TYPES.ELEMENT_NODE}`;	123✔
98
99	if (elementName === null \|\| star) {	123✔
100	return acceptAst(isElementCode, { type: GeneratedCodeBaseType.Value });	51✔
101	}
102
103	const qName = astHelper.getQName(astHelper.getFirstChild(elementName, 'QName'));	72✔
104
105	return emitNameTestFromQName(identifier, qName, staticContext);	72✔
106	}
107
108	// A node test that consists only of an EQName or a Wildcard is called a name test.
109	// https://www.w3.org/TR/xpath-31/#doc-xpath31-NameTest
110	function emitNameTest(ast: IAST, identifier: ContextItemIdentifier, staticContext: CodeGenContext) {
111	return emitNameTestFromQName(identifier, astHelper.getQName(ast), staticContext);	1,569✔
112	}
113
114	// select all element children of the context node
115	// for example: child::*.
116	// https://www.w3.org/TR/xpath-31/#doc-xpath31-Wildcard
117	function emitWildcard(
118	ast: IAST,
119	identifier: ContextItemIdentifier,
120	staticContext: CodeGenContext
121	): PartialCompilationResult {
122	if (!astHelper.getFirstChild(ast, 'star')) {	540✔
123	return emitNameTestFromQName(	444✔
124	identifier,
125	{
126	localName: '*',
127	namespaceURI: null,
128	prefix: '*',
129	},
130	staticContext
131	);
132	}
133
134	const uri = astHelper.getFirstChild(ast, 'uri');	96✔
135	if (uri) {	96!
UNCOV 136	return emitNameTestFromQName(	×
137	identifier,
138	{
139	localName: '*',
140	namespaceURI: astHelper.getTextContent(uri),
141	prefix: '',
142	},
143	staticContext
144	);
145	}
146
147	// Either the prefix or the localName are 'starred', find out which one
148	const ncName = astHelper.getFirstChild(ast, 'NCName');	96✔
149	if (astHelper.getFirstChild(ast, '*')[0] === 'star') {	96✔
150	// The prefix is 'starred'
151	return emitNameTestFromQName(	33✔
152	identifier,
153	{
154	localName: astHelper.getTextContent(ncName),
155	namespaceURI: null,
156	prefix: '*',
157	},
158	staticContext
159	);
160	}
161
162	// The localName is 'starred'
163	return emitNameTestFromQName(	63✔
164	identifier,
165	{
166	localName: '*',
167	namespaceURI: null,
168	prefix: astHelper.getTextContent(ncName),
169	},
170	staticContext
171	);
172	}
173
174	export default function emitTest(	18✔
175	ast: IAST,
176	identifier: ContextItemIdentifier,
177	staticContext: CodeGenContext
178	): PartialCompilationResult {
179	const test = ast[0];	2,307✔
180
181	switch (test) {	2,307✔
182	case testAstNodes.ELEMENT_TEST:	2,307!
183	return emitElementTest(ast, identifier, staticContext);	123✔
184	case testAstNodes.TEXT_TEST:
185	return emitTextTest(ast, identifier);	75✔
186	case testAstNodes.NAME_TEST:
187	return emitNameTest(ast, identifier, staticContext);	1,569✔
188	case testAstNodes.WILDCARD:
189	return emitWildcard(ast, identifier, staticContext);	540✔
190	default:
UNCOV 191	return rejectAst(`Unsupported: the test '${test}'.`);	×
192	}
193	}

FontoXML / fontoxpath / 1216892494

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