11973019680

Committed 22 Nov 2024 12:57PM UTC coverage: 91.505% (-0.07%) from 91.575%

Build # 11973019680

Build Type

Pull #660

github

Committed by

DrRataplan

Commit Message

Improve test coverage

Pull Request Pull Request #660: Implement otherwise and combinating tests from XQ4

Run Details

5053 of 5878 branches covered (85.96%)

Branch coverage included in aggregate %.

112 of 118 new or added lines in 11 files covered. (94.92%)

6 existing lines in 2 files now uncovered.

10867 of 11520 relevant lines covered (94.33%)

35624.81 hits per line

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

92.21

/src/parseScript.ts

import domBackedDocumentWriter from './documentWriter/domBackedDocumentWriter';
import IDocumentWriter from './documentWriter/IDocumentWriter';
import ExternalDomFacade from './domFacade/ExternalDomFacade';
import { printAndRethrowError } from './evaluationUtils/printAndRethrowError';
import { sequenceTypeToString } from './expressions/dataTypes/Value';
import ExecutionSpecificStaticContext from './expressions/ExecutionSpecificStaticContext';
import { BUILT_IN_NAMESPACE_URIS } from './expressions/staticallyKnownNamespaces';
import StaticContext from './expressions/StaticContext';
import ISimpleNodesFactory from './nodesFactory/ISimpleNodesFactory';
import astHelper, { IAST } from './parsing/astHelper';
import normalizeEndOfLines from './parsing/normalizeEndOfLines';
import parseExpression from './parsing/parseExpression';
import processProlog from './parsing/processProlog';
import annotateAst from './typeInference/annotateAST';
import { AnnotationContext } from './typeInference/AnnotationContext';
import { Language, Options } from './types/Options';
import { Element, Text } from './types/Types';

const PREFERRED_PREFIX_BY_NAMESPACEURI: { [prefix: string]: string } = {
        [BUILT_IN_NAMESPACE_URIS.XQUERYX_NAMESPACE_URI]: 'xqx',
        [BUILT_IN_NAMESPACE_URIS.XQUERYX_UPDATING_NAMESPACE_URI]: 'xquf',
        [BUILT_IN_NAMESPACE_URIS.FONTOXPATH_NAMESPACE_URI]: 'x',
};

function getQName(name: string, parentUri: string): { localName: string; namespaceUri: string } {
        switch (name) {
                case 'copySource':
                case 'insertAfter':
                case 'insertAsFirst':
                case 'insertAsLast':
                case 'insertBefore':
                case 'insertInto':
                case 'modifyExpr':
                case 'newNameExpr':
                case 'replacementExpr':
                case 'replaceValue':
                case 'returnExpr':
                case 'sourceExpr':
                case 'targetExpr':
                case 'transformCopies':
                case 'transformCopy':
                        // Some 'vanilla' elements are actually XQueryX elements. Check parent
                        return {
                                localName: name,
                                namespaceUri: parentUri || BUILT_IN_NAMESPACE_URIS.XQUERYX_NAMESPACE_URI,
                        };
                case 'deleteExpr':
                case 'insertExpr':
                case 'renameExpr':
                case 'replaceExpr':
                case 'transformExpr':
                        // Elements added in the update facility need to be in a different namespace
                        return {
                                localName: name,
                                namespaceUri: BUILT_IN_NAMESPACE_URIS.XQUERYX_UPDATING_NAMESPACE_URI,
                        };
                case 'x:stackTrace':
                        // Custom AST nodes introduced by fontoxpath for debugging
                        return {
                                localName: 'stackTrace',
                                namespaceUri: BUILT_IN_NAMESPACE_URIS.FONTOXPATH_NAMESPACE_URI,
                        };
                default:
                        return {
                                localName: name,
                                namespaceUri: BUILT_IN_NAMESPACE_URIS.XQUERYX_NAMESPACE_URI,
                        };
        }
}

/**
 * Transform the given JsonML fragment into the corresponding DOM structure, using the given document to
 * create nodes.
 *
 * JsonML is always expected to be a JavaScript structure. If you have a string of JSON, use JSON.parse first.
 *
 * @param   documentWriter -  Used to place nodes in the DOM
 * @param   simpleNodesFactory   -  Used to construct nodes
 * @param   jsonml   -  The JsonML fragment to parse
 * @param   parentUri
 * @param   skipEmptyPrefixes - Whether to output empty prefixes. This is closed to the spec XQueryX examples, but breaks assumptions in AST annotation
 *
 * @return  The root node of the constructed DOM fragment
 */
function parseNode(
        documentWriter: IDocumentWriter,
        simpleNodesFactory: ISimpleNodesFactory,
        jsonml: any[] | string,
        parentUri: string | null,
        skipEmptyPrefixes: boolean,
): Text | Element {
        if (typeof jsonml === 'string') {
                if (jsonml.length === 0) {
                        return null;
                }
                return simpleNodesFactory.createTextNode(jsonml);
        }

        if (!Array.isArray(jsonml)) {
                throw new TypeError('JsonML element should be an array or string');
        }

        const qName = getQName(jsonml[0], parentUri);
        const name = qName.localName;
        const namespaceUri = qName.namespaceUri;

        // Node must be a normal element
        const element = simpleNodesFactory.createElementNS(
                namespaceUri,
                PREFERRED_PREFIX_BY_NAMESPACEURI[namespaceUri] + ':' + name,
        );
        const firstChild = jsonml[1];
        let firstChildIndex = 1;
        if (typeof firstChild === 'object' && !Array.isArray(firstChild)) {
                if (firstChild !== null) {
                        for (const attributeName of Object.keys(firstChild)) {
                                let attributeValue = firstChild[attributeName];
                                if (attributeValue === null) {
                                        continue;
                                }
                                if (attributeName === 'type') {
                                        // TODO: prevent writing undefined to variables at the first place
                                        if (attributeValue !== undefined) {
                                                documentWriter.setAttributeNS(
                                                        element,
                                                        namespaceUri,
                                                        'fontoxpath:' + attributeName,
                                                        sequenceTypeToString(attributeValue),
                                                );
                                        }
                                        continue;
                                }
                                if (
                                        (attributeName === 'start' ||
                                                attributeName === 'end' ||
                                                attributeName === 'comment') &&
                                        name === 'stackTrace'
                                ) {
                                        attributeValue = JSON.stringify(attributeValue);
                                }
                                if (skipEmptyPrefixes && attributeName === 'prefix' && attributeValue === '') {
                                        continue;
                                }
                                documentWriter.setAttributeNS(
                                        element,
                                        namespaceUri,
                                        PREFERRED_PREFIX_BY_NAMESPACEURI[namespaceUri] + ':' + attributeName,
                                        attributeValue,
                                );
                        }
                }

                firstChildIndex = 2;
        }
        // Parse children
        for (let i = firstChildIndex, l = jsonml.length; i < l; ++i) {
                const node = parseNode(
                        documentWriter,
                        simpleNodesFactory,
                        jsonml[i] as any[] | string,
                        namespaceUri,
                        skipEmptyPrefixes,
                );
                if (node !== null) {
                        documentWriter.insertBefore(element, node, null);
                }
        }

        return element;
}

/**
 * Parse an XPath or XQuery script and output it as an XQueryX element. Refer to the [XQueryX
 * spec](https://www.w3.org/TR/xqueryx-31/) for more info.
 *
 * The precise generated XQueryX may change in the future when progress is made on supporting the
 * XQueryX test set provided with the [QT3 test suite](https://dev.w3.org/2011/QT3-test-suite/).
 *
 * Note that the parseScript function returns a detached element: it is not added to the passed
 * document.
 *
 * The element also contains the original expression as a comment.
 *
 * This may later be used for error processing to display the full original script instead of only referring to the AST.
 *
 * @example
 * Parse "self::element" to an XQueryX element and access it
 * ```
 * const xqueryx = parseScript(
 *   'self::element',
 *   {
 *     language: evaluateXPath.XPATH_3_1_LANGUAGE
 *   },
 *   new slimdom.Document()
 * );
 *
 * // Get the nametest element
 * const nameTestElement = evaluateXPathToFirstNode(
 *   'descendant-or-self::Q{http://www.w3.org/2005/XQueryX}nameTest',
 *   xqueryx)
 * ```
 *
 * @public
 *
 * @param script - The script to parse
 *
 * @param options - Additional options for parsing. Can be used to switch between parsing XPath or
 * XQuery update facility
 *
 * @param simpleNodesFactory - A NodesFactory will be used to create the DOM. This can be a
 * reference to the document in which the XQueryX will be created
 *
 * @param documentWriter - The documentWriter will be used to append children to the newly created
 * dom
 */
export default function parseScript<TElement extends Element>(
        script: string,
        options: Options & { annotateAst?: boolean },
        simpleNodesFactory: ISimpleNodesFactory,
        documentWriter: IDocumentWriter = domBackedDocumentWriter,
): TElement {
        script = normalizeEndOfLines(script);
        let ast: IAST;
        try {
                ast = parseExpression(script, {
                        allowXQuery:
                                options['language'] === Language.XQUERY_3_1_LANGUAGE ||
                                options['language'] === Language.XQUERY_UPDATE_3_1_LANGUAGE ||
                                options['language'] === Language.XQUERY_4_0_LANGUAGE ||
                                options['language'] === Language.XQUERY_UPDATE_4_0_LANGUAGE,
                        version:
                                options['language'] === Language.XPATH_4_0_LANGUAGE ||
                                options['language'] === Language.XQUERY_4_0_LANGUAGE ||
                                options['language'] === Language.XQUERY_UPDATE_4_0_LANGUAGE
                                        ? 4
                                        : 3.1,
                        debug: options.debug,
                });
        } catch (error) {
                printAndRethrowError(script, error);
        }

        // Let external options required for static evaluation flow in
        const executionSpecificStaticContext = new ExecutionSpecificStaticContext(
                options['namespaceResolver'] || ((_prefix: string) => null),
                {},
                options['defaultFunctionNamespaceURI'] === undefined
                        ? BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI
                        : options['defaultFunctionNamespaceURI'],
                options['functionNameResolver'] || (() => null),
        );
        const rootStaticContext = new StaticContext(executionSpecificStaticContext);
        const anyModuleDecl = astHelper.getFirstChild(ast, ['mainModule', 'libraryModule']);
        // Spike the static context if we are actually a library module
        const moduleDecl = astHelper.getFirstChild(anyModuleDecl, 'moduleDecl');
        if (moduleDecl) {
                const prefix = astHelper.getTextContent(astHelper.getFirstChild(moduleDecl, 'prefix'));
                const uri = astHelper.getTextContent(astHelper.getFirstChild(moduleDecl, 'uri'));

                rootStaticContext.registerNamespace(prefix, uri);
        }

        const prolog = astHelper.getFirstChild(anyModuleDecl, 'prolog');

        if (prolog) {
                processProlog(prolog, rootStaticContext, false, script);
        }

        if (options['annotateAst'] !== false) {
                const context = new AnnotationContext(rootStaticContext);
                annotateAst(ast, context);
        }

        const domFacade = new ExternalDomFacade();
        const astAsXML = parseNode(
                documentWriter,
                simpleNodesFactory,
                ast,
                null,
                options.annotateAst === false,
        ) as TElement;
        documentWriter.insertBefore(
                astAsXML,
                simpleNodesFactory.createComment(script),
                domFacade['getFirstChild'](astAsXML),
        );

        return astAsXML;
}

1	import domBackedDocumentWriter from './documentWriter/domBackedDocumentWriter';	6✔
2	import IDocumentWriter from './documentWriter/IDocumentWriter';
3	import ExternalDomFacade from './domFacade/ExternalDomFacade';	6✔
4	import { printAndRethrowError } from './evaluationUtils/printAndRethrowError';	6✔
5	import { sequenceTypeToString } from './expressions/dataTypes/Value';	6✔
6	import ExecutionSpecificStaticContext from './expressions/ExecutionSpecificStaticContext';	6✔
7	import { BUILT_IN_NAMESPACE_URIS } from './expressions/staticallyKnownNamespaces';
8	import StaticContext from './expressions/StaticContext';	6✔
9	import ISimpleNodesFactory from './nodesFactory/ISimpleNodesFactory';
10	import astHelper, { IAST } from './parsing/astHelper';	6✔
11	import normalizeEndOfLines from './parsing/normalizeEndOfLines';	6✔
12	import parseExpression from './parsing/parseExpression';	6✔
13	import processProlog from './parsing/processProlog';	6✔
14	import annotateAst from './typeInference/annotateAST';	6✔
15	import { AnnotationContext } from './typeInference/AnnotationContext';	6✔
16	import { Language, Options } from './types/Options';	6✔
17	import { Element, Text } from './types/Types';
18
19	const PREFERRED_PREFIX_BY_NAMESPACEURI: { [prefix: string]: string } = {	6✔
20	[BUILT_IN_NAMESPACE_URIS.XQUERYX_NAMESPACE_URI]: 'xqx',
21	[BUILT_IN_NAMESPACE_URIS.XQUERYX_UPDATING_NAMESPACE_URI]: 'xquf',
22	[BUILT_IN_NAMESPACE_URIS.FONTOXPATH_NAMESPACE_URI]: 'x',
23	};
24
25	function getQName(name: string, parentUri: string): { localName: string; namespaceUri: string } {
26	switch (name) {	125,004✔
27	case 'copySource':
28	case 'insertAfter':
29	case 'insertAsFirst':
30	case 'insertAsLast':
31	case 'insertBefore':
32	case 'insertInto':
33	case 'modifyExpr':
34	case 'newNameExpr':
35	case 'replacementExpr':
36	case 'replaceValue':
37	case 'returnExpr':
38	case 'sourceExpr':
39	case 'targetExpr':
40	case 'transformCopies':
41	case 'transformCopy':
42	// Some 'vanilla' elements are actually XQueryX elements. Check parent
43	return {	6,426✔
44	localName: name,
45	namespaceUri: parentUri \|\| BUILT_IN_NAMESPACE_URIS.XQUERYX_NAMESPACE_URI,	6,426!
46	};
47	case 'deleteExpr':
48	case 'insertExpr':
49	case 'renameExpr':
50	case 'replaceExpr':
51	case 'transformExpr':
52	// Elements added in the update facility need to be in a different namespace
53	return {	2,433✔
54	localName: name,
55	namespaceUri: BUILT_IN_NAMESPACE_URIS.XQUERYX_UPDATING_NAMESPACE_URI,
56	};
57	case 'x:stackTrace':
58	// Custom AST nodes introduced by fontoxpath for debugging
59	return {	39✔
60	localName: 'stackTrace',
61	namespaceUri: BUILT_IN_NAMESPACE_URIS.FONTOXPATH_NAMESPACE_URI,
62	};
63	default:
64	return {	116,106✔
65	localName: name,
66	namespaceUri: BUILT_IN_NAMESPACE_URIS.XQUERYX_NAMESPACE_URI,
67	};
68	}
69	}
70
71	/**
72	* Transform the given JsonML fragment into the corresponding DOM structure, using the given document to
73	* create nodes.
74	*
75	* JsonML is always expected to be a JavaScript structure. If you have a string of JSON, use JSON.parse first.
76	*
77	* @param documentWriter - Used to place nodes in the DOM
78	* @param simpleNodesFactory - Used to construct nodes
79	* @param jsonml - The JsonML fragment to parse
80	* @param parentUri
81	* @param skipEmptyPrefixes - Whether to output empty prefixes. This is closed to the spec XQueryX examples, but breaks assumptions in AST annotation
82	*
83	* @return The root node of the constructed DOM fragment
84	*/
85	function parseNode(
86	documentWriter: IDocumentWriter,
87	simpleNodesFactory: ISimpleNodesFactory,
88	jsonml: any[] \| string,
89	parentUri: string \| null,
90	skipEmptyPrefixes: boolean,
91	): Text \| Element {
92	if (typeof jsonml === 'string') {	161,784✔
93	if (jsonml.length === 0) {	36,780✔
94	return null;	27✔
95	}
96	return simpleNodesFactory.createTextNode(jsonml);	36,753✔
97	}
98
99	if (!Array.isArray(jsonml)) {	125,004!
100	throw new TypeError('JsonML element should be an array or string');	×
101	}
102
103	const qName = getQName(jsonml[0], parentUri);	125,004✔
104	const name = qName.localName;	125,004✔
105	const namespaceUri = qName.namespaceUri;	125,004✔
106
107	// Node must be a normal element
108	const element = simpleNodesFactory.createElementNS(	125,004✔
109	namespaceUri,
110	PREFERRED_PREFIX_BY_NAMESPACEURI[namespaceUri] + ':' + name,
111	);
112	const firstChild = jsonml[1];	125,004✔
113	let firstChildIndex = 1;	125,004✔
114	if (typeof firstChild === 'object' && !Array.isArray(firstChild)) {	125,004✔
115	if (firstChild !== null) {	51,816!
116	for (const attributeName of Object.keys(firstChild)) {	51,816✔
117	let attributeValue = firstChild[attributeName];	73,890✔
118	if (attributeValue === null) {	73,890✔
119	continue;	24,756✔
120	}
121	if (attributeName === 'type') {	49,134✔
122	// TODO: prevent writing undefined to variables at the first place
123	if (attributeValue !== undefined) {	27,723✔
124	documentWriter.setAttributeNS(	25,887✔
125	element,
126	namespaceUri,
127	'fontoxpath:' + attributeName,
128	sequenceTypeToString(attributeValue),
129	);
130	}
131	continue;	27,723✔
132	}
133	if (	21,411✔
134	(attributeName === 'start' \|\|	64,197✔
135	attributeName === 'end' \|\|
136	attributeName === 'comment') &&
137	name === 'stackTrace'
138	) {
139	attributeValue = JSON.stringify(attributeValue);	81✔
140	}
141	if (skipEmptyPrefixes && attributeName === 'prefix' && attributeValue === '') {	21,411!
UNCOV 142	continue;	×
143	}
144	documentWriter.setAttributeNS(	21,411✔
145	element,
146	namespaceUri,
147	PREFERRED_PREFIX_BY_NAMESPACEURI[namespaceUri] + ':' + attributeName,
148	attributeValue,
149	);
150	}
151	}
152
153	firstChildIndex = 2;	51,816✔
154	}
155	// Parse children
156	for (let i = firstChildIndex, l = jsonml.length; i < l; ++i) {	125,004✔
157	const node = parseNode(	159,000✔
158	documentWriter,
159	simpleNodesFactory,
160	jsonml[i] as any[] \| string,
161	namespaceUri,
162	skipEmptyPrefixes,
163	);
164	if (node !== null) {	159,000✔
165	documentWriter.insertBefore(element, node, null);	158,973✔
166	}
167	}
168
169	return element;	125,004✔
170	}
171
172	/**
173	* Parse an XPath or XQuery script and output it as an XQueryX element. Refer to the [XQueryX
174	* spec](https://www.w3.org/TR/xqueryx-31/) for more info.
175	*
176	* The precise generated XQueryX may change in the future when progress is made on supporting the
177	* XQueryX test set provided with the [QT3 test suite](https://dev.w3.org/2011/QT3-test-suite/).
178	*
179	* Note that the parseScript function returns a detached element: it is not added to the passed
180	* document.
181	*
182	* The element also contains the original expression as a comment.
183	*
184	* This may later be used for error processing to display the full original script instead of only referring to the AST.
185	*
186	* @example
187	* Parse "self::element" to an XQueryX element and access it
188	* ```
189	* const xqueryx = parseScript(
190	* 'self::element',
191	* {
192	* language: evaluateXPath.XPATH_3_1_LANGUAGE
193	* },
194	* new slimdom.Document()
195	* );
196	*
197	* // Get the nametest element
198	* const nameTestElement = evaluateXPathToFirstNode(
199	* 'descendant-or-self::Q{http://www.w3.org/2005/XQueryX}nameTest',
200	* xqueryx)
201	* ```
202	*
203	* @public
204	*
205	* @param script - The script to parse
206	*
207	* @param options - Additional options for parsing. Can be used to switch between parsing XPath or
208	* XQuery update facility
209	*
210	* @param simpleNodesFactory - A NodesFactory will be used to create the DOM. This can be a
211	* reference to the document in which the XQueryX will be created
212	*
213	* @param documentWriter - The documentWriter will be used to append children to the newly created
214	* dom
215	*/
216	export default function parseScript<TElement extends Element>(	6✔
217	script: string,
218	options: Options & { annotateAst?: boolean },
219	simpleNodesFactory: ISimpleNodesFactory,
220	documentWriter: IDocumentWriter = domBackedDocumentWriter,	2,784✔
221	): TElement {
222	script = normalizeEndOfLines(script);	2,784✔
223	let ast: IAST;
224	try {	2,784✔
225	ast = parseExpression(script, {	2,784✔
226	allowXQuery:
227	options['language'] === Language.XQUERY_3_1_LANGUAGE \|\|	3,399✔
228	options['language'] === Language.XQUERY_UPDATE_3_1_LANGUAGE \|\|
229	options['language'] === Language.XQUERY_4_0_LANGUAGE \|\|
230	options['language'] === Language.XQUERY_UPDATE_4_0_LANGUAGE,
231	version:
232	options['language'] === Language.XPATH_4_0_LANGUAGE \|\|	11,136!
233	options['language'] === Language.XQUERY_4_0_LANGUAGE \|\|
234	options['language'] === Language.XQUERY_UPDATE_4_0_LANGUAGE
235	? 4
236	: 3.1,
237	debug: options.debug,
238	});
239	} catch (error) {
240	printAndRethrowError(script, error);	×
241	}
242
243	// Let external options required for static evaluation flow in
244	const executionSpecificStaticContext = new ExecutionSpecificStaticContext(	2,784✔
245	options['namespaceResolver'] \|\| ((_prefix: string) => null),	14,109✔
246	{},
247	options['defaultFunctionNamespaceURI'] === undefined	2,784!
248	? BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI
249	: options['defaultFunctionNamespaceURI'],
250	options['functionNameResolver'] \|\| (() => null),	966✔
251	);
252	const rootStaticContext = new StaticContext(executionSpecificStaticContext);	2,784✔
253	const anyModuleDecl = astHelper.getFirstChild(ast, ['mainModule', 'libraryModule']);	2,784✔
254	// Spike the static context if we are actually a library module
255	const moduleDecl = astHelper.getFirstChild(anyModuleDecl, 'moduleDecl');	2,784✔
256	if (moduleDecl) {	2,784✔
257	const prefix = astHelper.getTextContent(astHelper.getFirstChild(moduleDecl, 'prefix'));	3✔
258	const uri = astHelper.getTextContent(astHelper.getFirstChild(moduleDecl, 'uri'));	3✔
259
260	rootStaticContext.registerNamespace(prefix, uri);	3✔
261	}
262
263	const prolog = astHelper.getFirstChild(anyModuleDecl, 'prolog');	2,784✔
264
265	if (prolog) {	2,784✔
266	processProlog(prolog, rootStaticContext, false, script);	2,415✔
267	}
268
269	if (options['annotateAst'] !== false) {	2,784!
270	const context = new AnnotationContext(rootStaticContext);	2,784✔
271	annotateAst(ast, context);	2,784✔
272	}
273
274	const domFacade = new ExternalDomFacade();	2,784✔
275	const astAsXML = parseNode(	2,784✔
276	documentWriter,
277	simpleNodesFactory,
278	ast,
279	null,
280	options.annotateAst === false,
281	) as TElement;
282	documentWriter.insertBefore(	2,784✔
283	astAsXML,
284	simpleNodesFactory.createComment(script),
285	domFacade['getFirstChild'](astAsXML),
286	);
287
288	return astAsXML;	2,784✔
289	}

FontoXML / fontoxpath / 11973019680

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