1045271283

Build Type

github

Committed by GitHub

Commit Message

Merge 48c766f2d into 91e42575e

Pull Request Pull Request #397: Compare jscodegen

Run Details

4706 of 5052 branches covered (93.15%)

Branch coverage included in aggregate %.

174 of 180 new or added lines in 11 files covered. (96.67%)

1 existing line in 1 file now uncovered.

9369 of 9596 relevant lines covered (97.63%)

5683887.87 hits per line

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

95.56

/src/jsCodegen/emitPathExpr.ts

import { NODE_TYPES } from '../domFacade/ConcreteNode';
import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import emitStep from './emitStep';
import emitTest, { tests } from './emitTest';
import {
        acceptAst,
        FunctionIdentifier,
        getCompiledValueCode,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';

/**
 * Determines for every path step if it should emit a node or not.
 *
 * @param predicatesAst AST node for the predicate.
 * @param nestLevel The nest level within the path expression.
 * @param staticContext Static context parameter to retrieve context-dependent information.
 * @returns JavaScript code of the steps predicates.
 */
function emitPredicates(
        predicatesAst: IAST,
        nestLevel: number,
        staticContext: CodeGenContext
): PartialCompilationResult {
        let evaluatePredicateConditionCode = '';
        const functionDeclarations: string[] = [];

        if (!predicatesAst) {
                return acceptAst(``, false, functionDeclarations);
        }

        const children = astHelper.getChildren(predicatesAst, '*');
        for (let i = 0; i < children.length; i++) {
                const predicate = children[i];
                const predicateFunctionIdentifier = `step${nestLevel}_predicate${i}`;

                // Prepare condition used to determine if an axis should
                // return a node.
                const predicateFunctionCall = `determinePredicateTruthValue(${getCompiledValueCode(
                        predicateFunctionIdentifier,
                        true,
                        `contextItem${nestLevel}`
                )})`;
                if (i === 0) {
                        evaluatePredicateConditionCode += predicateFunctionCall;
                } else {
                        evaluatePredicateConditionCode = `${evaluatePredicateConditionCode} && ${predicateFunctionCall}`;
                }

                const compiledPredicate = staticContext.emitBaseExpr(
                        predicate,
                        predicateFunctionIdentifier,
                        staticContext
                );
                if (compiledPredicate.isAstAccepted) {
                        functionDeclarations.push(compiledPredicate.code);
                } else {
                        return compiledPredicate;
                }
        }
        return acceptAst(evaluatePredicateConditionCode, true, functionDeclarations);
}

/**
 * Takes the step AST's of a path expression and turns it into runnable JavaScript code.
 *
 * @param stepsAst AST nodes of the path expression steps
 * @param staticContext Static context parameter to retrieve context-dependent information.
 * @returns JavaScript code of the path expression steps.
 */
function emitSteps(stepsAst: IAST[], staticContext: CodeGenContext): PartialCompilationResult {
        if (stepsAst.length === 0) {
                return acceptAst(
                        `
                        if (!hasReturned) {
                                hasReturned = true;
                                return ready(adaptSingleJavaScriptValue(contextItem, domFacade));
                        }
                        `,
                        false,
                        ['let hasReturned = false;']
                );
        }

        let emittedCode = '';
        const emittedVariables: string[] = [];
        for (let i = stepsAst.length - 1; i >= 0; i--) {
                const step = stepsAst[i];
                const nestLevel = i + 1;

                const predicatesAst = astHelper.getFirstChild(step, 'predicates');
                const emittedPredicates = emitPredicates(predicatesAst, nestLevel, staticContext);
                if (!emittedPredicates.isAstAccepted) {
                        return emittedPredicates;
                }

                const axisAst = astHelper.getFirstChild(step, 'xpathAxis');
                if (axisAst) {
                        const emittedStepsCode = emittedCode;
                        const testAst = astHelper.getFirstChild(step, tests);
                        if (!testAst) {
                                return rejectAst(`Unsupported: the test in the '${step}' step.`);
                        }

                        // Only the innermost nested step returns a value.
                        const nestedCode =
                                i === stepsAst.length - 1
                                        ? `i${nestLevel}++;\nreturn ready(adaptSingleJavaScriptValue(contextItem${nestLevel}, domFacade));`
                                        : `${emittedStepsCode}\ni${nestLevel}++;`;

                        const emittedTest = emitTest(testAst, `contextItem${nestLevel}`, staticContext);
                        if (!emittedTest.isAstAccepted) {
                                return emittedTest;
                        }

                        const emittedStep = emitStep(
                                axisAst,
                                emittedTest.code,
                                emittedPredicates.code,
                                nestLevel,
                                nestedCode
                        );
                        if (!emittedStep.isAstAccepted) {
                                return emittedStep;
                        }

                        emittedVariables.push(...emittedStep.variables, ...emittedPredicates.variables);
                        emittedCode = emittedStep.code;
                } else {
                        return rejectAst('Unsupported: filter expressions.');
                }

                const lookups = astHelper.getChildren(step, 'lookup');
                if (lookups.length > 0) {
                        return rejectAst('Unsupported: lookups.');
                }
        }
        const contextDeclaration = 'const contextItem0 = contextItem;';
        emittedCode = contextDeclaration + emittedCode;

        return acceptAst(emittedCode, true, emittedVariables);
}

/**
 * Takes a path expression AST node and turns it into a javascript function.
 * Path expression can be used to locate nodes within trees and they
 * consist of a series of one or more steps.
 *
 * https://www.w3.org/TR/xpath-31/#doc-xpath31-PathExpr
 *
 * @param ast AST node of the path expression
 * @param identifier Function identifier for the emitted code.
 * @param staticContext Static context parameter to retrieve context-dependent information.
 * @returns JavaScript code of the path expression AST node.
 */
export function emitPathExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext
): PartialCompilationResult {
        // Find the root node from the context.
        const isAbsolute = astHelper.getFirstChild(ast, 'rootExpr');
        let absoluteCode = '';
        if (isAbsolute) {
                absoluteCode = `
                let documentNode = contextItem;
                while (documentNode.nodeType !== ${NODE_TYPES.DOCUMENT_NODE}) {
                        documentNode = domFacade.getParentNode(documentNode);
                        if (documentNode === null) {
                                throw new Error('XPDY0050: the root node of the context node is not a document node.');
                        }
                }
                contextItem = documentNode;
                `;
        }

        const emittedSteps = emitSteps(astHelper.getChildren(ast, 'stepExpr'), staticContext);
        if (!emittedSteps.isAstAccepted) {
                return emittedSteps;
        }

        const pathExprCode = `
        function ${identifier}(contextItem) {
                ${absoluteCode}
                ${emittedSteps.variables.join('\n')}
                const next = () => {
                        ${emittedSteps.code}
                        return DONE_TOKEN;
                };
                return {
                        next,
                        [Symbol.iterator]() { return this; }
                };
        }
        `;

        return acceptAst(pathExprCode, true);
}

1	import { NODE_TYPES } from '../domFacade/ConcreteNode';
2	import astHelper, { IAST } from '../parsing/astHelper';	18✔
3	import { CodeGenContext } from './CodeGenContext';
4	import emitStep from './emitStep';	18✔
5	import emitTest, { tests } from './emitTest';	18✔
6	import {	18✔
7	acceptAst,
8	FunctionIdentifier,
9	getCompiledValueCode,
10	PartialCompilationResult,
11	rejectAst,
12	} from './JavaScriptCompiledXPath';
13
14	/**
15	* Determines for every path step if it should emit a node or not.
16	*
17	* @param predicatesAst AST node for the predicate.
18	* @param nestLevel The nest level within the path expression.
19	* @param staticContext Static context parameter to retrieve context-dependent information.
20	* @returns JavaScript code of the steps predicates.
21	*/
22	function emitPredicates(
23	predicatesAst: IAST,
24	nestLevel: number,
25	staticContext: CodeGenContext
26	): PartialCompilationResult {
27	let evaluatePredicateConditionCode = '';	6,312✔
28	const functionDeclarations: string[] = [];	6,312✔
29
30	if (!predicatesAst) {	6,312✔
31	return acceptAst(``, false, functionDeclarations);	4,377✔
32	}
33
34	const children = astHelper.getChildren(predicatesAst, '*');	1,935✔
35	for (let i = 0; i < children.length; i++) {	1,935✔
36	const predicate = children[i];	1,962✔
37	const predicateFunctionIdentifier = `step${nestLevel}_predicate${i}`;	1,962✔
38
39	// Prepare condition used to determine if an axis should
40	// return a node.
41	const predicateFunctionCall = `determinePredicateTruthValue(${getCompiledValueCode(	1,962✔
42	predicateFunctionIdentifier,
43	true,
44	`contextItem${nestLevel}`
45	)})`;
46	if (i === 0) {	1,962✔
47	evaluatePredicateConditionCode += predicateFunctionCall;	1,935✔
48	} else {
49	evaluatePredicateConditionCode = `${evaluatePredicateConditionCode} && ${predicateFunctionCall}`;	27✔
50	}
51
52	const compiledPredicate = staticContext.emitBaseExpr(	1,962✔
53	predicate,
54	predicateFunctionIdentifier,
55	staticContext
56	);
57	if (compiledPredicate.isAstAccepted) {	1,962✔
58	functionDeclarations.push(compiledPredicate.code);	90✔
59	} else {
60	return compiledPredicate;	1,872✔
61	}
62	}
63	return acceptAst(evaluatePredicateConditionCode, true, functionDeclarations);	63✔
64	}
65
66	/**
67	* Takes the step AST's of a path expression and turns it into runnable JavaScript code.
68	*
69	* @param stepsAst AST nodes of the path expression steps
70	* @param staticContext Static context parameter to retrieve context-dependent information.
71	* @returns JavaScript code of the path expression steps.
72	*/
73	function emitSteps(stepsAst: IAST[], staticContext: CodeGenContext): PartialCompilationResult {
74	if (stepsAst.length === 0) {	5,211✔
75	return acceptAst(	39✔
76	`
77	if (!hasReturned) {
78	hasReturned = true;
79	return ready(adaptSingleJavaScriptValue(contextItem, domFacade));
80	}
81	`,
82	false,
83	['let hasReturned = false;']
84	);
85	}
86
87	let emittedCode = '';	5,172✔
88	const emittedVariables: string[] = [];	5,172✔
89	for (let i = stepsAst.length - 1; i >= 0; i--) {	5,172✔
90	const step = stepsAst[i];	6,312✔
91	const nestLevel = i + 1;	6,312✔
92
93	const predicatesAst = astHelper.getFirstChild(step, 'predicates');	6,312✔
94	const emittedPredicates = emitPredicates(predicatesAst, nestLevel, staticContext);	6,312✔
95	if (!emittedPredicates.isAstAccepted) {	6,312✔
96	return emittedPredicates;	1,872✔
97	}
98
99	const axisAst = astHelper.getFirstChild(step, 'xpathAxis');	4,440✔
100	if (axisAst) {	4,440✔
101	const emittedStepsCode = emittedCode;	3,192✔
102	const testAst = astHelper.getFirstChild(step, tests);	3,192✔
103	if (!testAst) {	3,192✔
104	return rejectAst(`Unsupported: the test in the '${step}' step.`);	1,023✔
105	}
106
107	// Only the innermost nested step returns a value.
108	const nestedCode =
109	i === stepsAst.length - 1	2,169✔
110	? `i${nestLevel}++;\nreturn ready(adaptSingleJavaScriptValue(contextItem${nestLevel}, domFacade));`	2,169✔
111	: `${emittedStepsCode}\ni${nestLevel}++;`;
112
113	const emittedTest = emitTest(testAst, `contextItem${nestLevel}`, staticContext);	2,169✔
114	if (!emittedTest.isAstAccepted) {	2,121!
NEW 115	return emittedTest;	×
116	}
117
118	const emittedStep = emitStep(	2,121✔
119	axisAst,
120	emittedTest.code,
121	emittedPredicates.code,
122	nestLevel,
123	nestedCode
124	);
125	if (!emittedStep.isAstAccepted) {	2,121✔
126	return emittedStep;	456✔
127	}
128
129	emittedVariables.push(...emittedStep.variables, ...emittedPredicates.variables);	1,665✔
130	emittedCode = emittedStep.code;	1,665✔
131	} else {
132	return rejectAst('Unsupported: filter expressions.');	1,248✔
133	}
134
135	const lookups = astHelper.getChildren(step, 'lookup');	1,665✔
136	if (lookups.length > 0) {	1,665!
NEW 137	return rejectAst('Unsupported: lookups.');	×
138	}
139	}
140	const contextDeclaration = 'const contextItem0 = contextItem;';	525✔
141	emittedCode = contextDeclaration + emittedCode;	525✔
142
143	return acceptAst(emittedCode, true, emittedVariables);	525✔
144	}
145
146	/**
147	* Takes a path expression AST node and turns it into a javascript function.
148	* Path expression can be used to locate nodes within trees and they
149	* consist of a series of one or more steps.
150	*
151	* https://www.w3.org/TR/xpath-31/#doc-xpath31-PathExpr
152	*
153	* @param ast AST node of the path expression
154	* @param identifier Function identifier for the emitted code.
155	* @param staticContext Static context parameter to retrieve context-dependent information.
156	* @returns JavaScript code of the path expression AST node.
157	*/
158	export function emitPathExpr(	18✔
159	ast: IAST,
160	identifier: FunctionIdentifier,
161	staticContext: CodeGenContext
162	): PartialCompilationResult {
163	// Find the root node from the context.
164	const isAbsolute = astHelper.getFirstChild(ast, 'rootExpr');	5,211✔
165	let absoluteCode = '';	5,211✔
166	if (isAbsolute) {	5,211✔
167	absoluteCode = `	2,331✔
168	let documentNode = contextItem;
169	while (documentNode.nodeType !== ${NODE_TYPES.DOCUMENT_NODE}) {
170	documentNode = domFacade.getParentNode(documentNode);
171	if (documentNode === null) {
172	throw new Error('XPDY0050: the root node of the context node is not a document node.');
173	}
174	}
175	contextItem = documentNode;
176	`;
177	}
178
179	const emittedSteps = emitSteps(astHelper.getChildren(ast, 'stepExpr'), staticContext);	5,211✔
180	if (!emittedSteps.isAstAccepted) {	5,163✔
181	return emittedSteps;	4,599✔
182	}
183
184	const pathExprCode = `	564✔
185	function ${identifier}(contextItem) {
186	${absoluteCode}
187	${emittedSteps.variables.join('\n')}
188	const next = () => {
189	${emittedSteps.code}
190	return DONE_TOKEN;
191	};
192	return {
193	next,
194	[Symbol.iterator]() { return this; }
195	};
196	}
197	`;
198
199	return acceptAst(pathExprCode, true);	564✔
200	}

FontoXML / fontoxpath / 1045271283

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