874864331

Build Type

github

Committed by GitHub

Commit Message

Merge fc322445a into 2e1a17de7

Pull Request Pull Request #358: Fix errors caused by not checking if a context node is truthy

Run Details

4410 of 4746 branches covered (92.92%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

8644 of 8885 relevant lines covered (97.29%)

3741212.39 hits per line

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

96.8

/src/jsCodegen/emitBaseExpression.ts

import astHelper, { IAST } from '../parsing/astHelper';
import emitStep from './emitStep';
import emitTest, { tests } from './emitTest';
import {
        acceptAst,
        FunctionIdentifier,
        PartialCompilationResult,
        rejectAst,
} from './JavaScriptCompiledXPath';
import { StaticContext } from './StaticContext';

const baseExprAstNodes = {
        PATH_EXPR: 'pathExpr',
        AND_OP: 'andOp',
        OR_OP: 'orOp',
};

const baseExpressions = Object.values(baseExprAstNodes);

function emitPredicates(
        predicatesAst: IAST,
        nestLevel: number,
        staticContext: StaticContext
): PartialCompilationResult {
        let evaluatePredicateConditionCode = '';
        const functionDeclarations: string[] = [];

        if (!predicatesAst) {
                return acceptAst(evaluatePredicateConditionCode, 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(${predicateFunctionIdentifier}(contextItem${nestLevel}))`;
                if (i === 0) {
                        evaluatePredicateConditionCode += predicateFunctionCall;
                } else {
                        evaluatePredicateConditionCode = `${evaluatePredicateConditionCode} && ${predicateFunctionCall}`;
                }

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

function emitSteps(stepsAst: IAST[], staticContext: StaticContext): PartialCompilationResult {
        if (stepsAst.length === 0) {
                return acceptAst(
                        `
                        if (!hasReturned) {
                                hasReturned = true;
                                return ready(adaptSingleJavaScriptValue(contextItem, domFacade));
                        }
                        `,
                        ['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, emittedVariables);
}

// A path expression can be used to locate nodes within trees. A path expression
// consists of a series of one or more steps.
// https://www.w3.org/TR/xpath-31/#doc-xpath31-PathExpr
function emitPathExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: StaticContext
): PartialCompilationResult {
        const emittedSteps = emitSteps(astHelper.getChildren(ast, 'stepExpr'), staticContext);
        if (!emittedSteps.isAstAccepted) {
                return emittedSteps;
        }

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

        return acceptAst(pathExprCode);
}

const firstOperandIdentifier = 'firstOperand';
const secondOperandIdentifier = 'secondOperand';

function emitOperand(
        ast: IAST,
        identifier: FunctionIdentifier,
        operandKind: 'firstOperand' | 'secondOperand',
        staticContext: StaticContext
): PartialCompilationResult {
        const operand = astHelper.getFirstChild(ast, operandKind);
        const exprAst = astHelper.getFirstChild(operand, baseExpressions);
        if (!exprAst) {
                return rejectAst('Unsupported: a base expression used with an operand.');
        }

        const baseExprIdentifier = identifier + operandKind;

        const baseExpr = emitBaseExpr(exprAst, baseExprIdentifier, staticContext);
        if (!baseExpr.isAstAccepted) {
                return baseExpr;
        }

        return acceptAst(`determinePredicateTruthValue(${baseExprIdentifier}(contextItem))`, [
                baseExpr.code,
        ]);
}

// https://www.w3.org/TR/xpath-31/#doc-xpath31-AndExpr
function emitAndExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: StaticContext
): PartialCompilationResult {
        return emitLogicalExpr(ast, identifier, staticContext, '&&');
}

// https://www.w3.org/TR/xpath-31/#doc-xpath31-OrExpr
function emitOrExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: StaticContext
): PartialCompilationResult {
        return emitLogicalExpr(ast, identifier, staticContext, '||');
}

function emitLogicalExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: StaticContext,
        logicalExprOperator: '&&' | '||'
) {
        const firstExpr = emitOperand(ast, identifier, firstOperandIdentifier, staticContext);
        if (!firstExpr.isAstAccepted) {
                return firstExpr;
        }

        const secondExpr = emitOperand(ast, identifier, secondOperandIdentifier, staticContext);
        if (!secondExpr.isAstAccepted) {
                return secondExpr;
        }

        const andOpCode = `
        function ${identifier}(contextItem) {
                ${firstExpr.variables.join('\n')}
                ${secondExpr.variables.join('\n')}
                return ${firstExpr.code} ${logicalExprOperator} ${secondExpr.code}
        }
        `;
        return acceptAst(andOpCode);
}

// Compile AST to base expression contained in a function named as the given
// identifier.
export function emitBaseExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: StaticContext
): PartialCompilationResult {
        const name = ast[0];

        switch (name) {
                case baseExprAstNodes.PATH_EXPR:
                        return emitPathExpr(ast, identifier, staticContext);
                case baseExprAstNodes.AND_OP:
                        return emitAndExpr(ast, identifier, staticContext);
                case baseExprAstNodes.OR_OP:
                        return emitOrExpr(ast, identifier, staticContext);
                default:
                        return rejectAst(`Unsupported: the base expression '${name}'.`);
        }
}

1	import astHelper, { IAST } from '../parsing/astHelper';	15✔
2	import emitStep from './emitStep';	15✔
3	import emitTest, { tests } from './emitTest';	15✔
4	import {	15✔
5	acceptAst,
6	FunctionIdentifier,
7	PartialCompilationResult,
8	rejectAst,
9	} from './JavaScriptCompiledXPath';
10	import { StaticContext } from './StaticContext';
11
12	const baseExprAstNodes = {	15✔
13	PATH_EXPR: 'pathExpr',
14	AND_OP: 'andOp',
15	OR_OP: 'orOp',
16	};
17
18	const baseExpressions = Object.values(baseExprAstNodes);	15✔
19
20	function emitPredicates(
21	predicatesAst: IAST,
22	nestLevel: number,
23	staticContext: StaticContext
24	): PartialCompilationResult {
25	let evaluatePredicateConditionCode = '';	2,784✔
26	const functionDeclarations: string[] = [];	2,784✔
27
28	if (!predicatesAst) {	2,784✔
29	return acceptAst(evaluatePredicateConditionCode, functionDeclarations);	2,112✔
30	}
31
32	const children = astHelper.getChildren(predicatesAst, '*');	672✔
33	for (let i = 0; i < children.length; i++) {	672✔
34	const predicate = children[i];	687✔
35	const predicateFunctionIdentifier = `step${nestLevel}_predicate${i}`;	687✔
36
37	// Prepare condition used to determine if an axis should
38	// return a node.
39	const predicateFunctionCall = `determinePredicateTruthValue(${predicateFunctionIdentifier}(contextItem${nestLevel}))`;	687✔
40	if (i === 0) {	687✔
41	evaluatePredicateConditionCode += predicateFunctionCall;	672✔
42	} else {
43	evaluatePredicateConditionCode = `${evaluatePredicateConditionCode} && ${predicateFunctionCall}`;	15✔
44	}
45
46	const compiledPredicate = emitBaseExpr(	687✔
47	predicate,
48	predicateFunctionIdentifier,
49	staticContext
50	);
51	if (compiledPredicate.isAstAccepted) {	687✔
52	functionDeclarations.push(compiledPredicate.code);	42✔
53	} else {
54	return compiledPredicate;	645✔
55	}
56	}
57	return acceptAst(evaluatePredicateConditionCode, functionDeclarations);	27✔
58	}
59
60	function emitSteps(stepsAst: IAST[], staticContext: StaticContext): PartialCompilationResult {
61	if (stepsAst.length === 0) {	2,217✔
62	return acceptAst(	6✔
63	`
64	if (!hasReturned) {
65	hasReturned = true;
66	return ready(adaptSingleJavaScriptValue(contextItem, domFacade));
67	}
68	`,
69	['let hasReturned = false;']
70	);
71	}
72
73	let emittedCode = '';	2,211✔
74	const emittedVariables: string[] = [];	2,211✔
75	for (let i = stepsAst.length - 1; i >= 0; i--) {	2,211✔
76	const step = stepsAst[i];	2,784✔
77	const nestLevel = i + 1;	2,784✔
78
79	const predicatesAst = astHelper.getFirstChild(step, 'predicates');	2,784✔
80	const emittedPredicates = emitPredicates(predicatesAst, nestLevel, staticContext);	2,784✔
81	if (!emittedPredicates.isAstAccepted) {	2,784✔
82	return emittedPredicates;	645✔
83	}
84
85	const axisAst = astHelper.getFirstChild(step, 'xpathAxis');	2,139✔
86	if (axisAst) {	2,139✔
87	const emittedStepsCode = emittedCode;	1,575✔
88	const testAst = astHelper.getFirstChild(step, tests);	1,575✔
89	if (!testAst) {	1,575✔
90	return rejectAst(`Unsupported: the test in the '${step}' step.`);	516✔
91	}
92
93	// Only the innermost nested step returns a value.
94	const nestedCode =
95	i === stepsAst.length - 1	1,059✔
96	? `i${nestLevel}++;\nreturn ready(adaptSingleJavaScriptValue(contextItem${nestLevel}, domFacade));`	1,059✔
97	: `${emittedStepsCode}\ni${nestLevel}++;`;
98
99	const emittedTest = emitTest(testAst, `contextItem${nestLevel}`, staticContext);	1,059✔
100	if (!emittedTest.isAstAccepted) {	1,035!
UNCOV 101	return emittedTest;	×
102	}
103
104	const emittedStep = emitStep(	1,035✔
105	axisAst,
106	emittedTest.code,
107	emittedPredicates.code,
108	nestLevel,
109	nestedCode
110	);
111	if (!emittedStep.isAstAccepted) {	1,035✔
112	return emittedStep;	240✔
113	}
114
115	emittedVariables.push(...emittedStep.variables, ...emittedPredicates.variables);	795✔
116	emittedCode = emittedStep.code;	795✔
117	} else {
118	return rejectAst('Unsupported: filter expressions.');	564✔
119	}
120
121	const lookups = astHelper.getChildren(step, 'lookup');	795✔
122	if (lookups.length > 0) {	795!
UNCOV 123	return rejectAst('Unsupported: lookups.');	×
124	}
125	}
126	const contextDeclaration = 'const contextItem0 = contextItem;';	222✔
127	emittedCode = contextDeclaration + emittedCode;	222✔
128
129	return acceptAst(emittedCode, emittedVariables);	222✔
130	}
131
132	// A path expression can be used to locate nodes within trees. A path expression
133	// consists of a series of one or more steps.
134	// https://www.w3.org/TR/xpath-31/#doc-xpath31-PathExpr
135	function emitPathExpr(
136	ast: IAST,
137	identifier: FunctionIdentifier,
138	staticContext: StaticContext
139	): PartialCompilationResult {
140	const emittedSteps = emitSteps(astHelper.getChildren(ast, 'stepExpr'), staticContext);	2,217✔
141	if (!emittedSteps.isAstAccepted) {	2,193✔
142	return emittedSteps;	1,965✔
143	}
144
145	const pathExprCode = `	228✔
146	function ${identifier}(contextItem) {
147	${emittedSteps.variables.join('\n')}
148	const next = () => {
149	${emittedSteps.code}
150	return DONE_TOKEN;
151	};
152	return {
153	next,
154	[Symbol.iterator]() { return this; }
155	};
156	}
157	`;
158
159	return acceptAst(pathExprCode);	228✔
160	}
161
162	const firstOperandIdentifier = 'firstOperand';	15✔
163	const secondOperandIdentifier = 'secondOperand';	15✔
164
165	function emitOperand(
166	ast: IAST,
167	identifier: FunctionIdentifier,
168	operandKind: 'firstOperand' \| 'secondOperand',
169	staticContext: StaticContext
170	): PartialCompilationResult {
171	const operand = astHelper.getFirstChild(ast, operandKind);	4,008✔
172	const exprAst = astHelper.getFirstChild(operand, baseExpressions);	4,008✔
173	if (!exprAst) {	4,008✔
174	return rejectAst('Unsupported: a base expression used with an operand.');	3,858✔
175	}
176
177	const baseExprIdentifier = identifier + operandKind;	150✔
178
179	const baseExpr = emitBaseExpr(exprAst, baseExprIdentifier, staticContext);	150✔
180	if (!baseExpr.isAstAccepted) {	150✔
181	return baseExpr;	96✔
182	}
183
184	return acceptAst(`determinePredicateTruthValue(${baseExprIdentifier}(contextItem))`, [	54✔
185	baseExpr.code,
186	]);
187	}
188
189	// https://www.w3.org/TR/xpath-31/#doc-xpath31-AndExpr
190	function emitAndExpr(
191	ast: IAST,
192	identifier: FunctionIdentifier,
193	staticContext: StaticContext
194	): PartialCompilationResult {
195	return emitLogicalExpr(ast, identifier, staticContext, '&&');	2,967✔
196	}
197
198	// https://www.w3.org/TR/xpath-31/#doc-xpath31-OrExpr
199	function emitOrExpr(
200	ast: IAST,
201	identifier: FunctionIdentifier,
202	staticContext: StaticContext
203	): PartialCompilationResult {
204	return emitLogicalExpr(ast, identifier, staticContext, '\|\|');	1,008✔
205	}
206
207	function emitLogicalExpr(
208	ast: IAST,
209	identifier: FunctionIdentifier,
210	staticContext: StaticContext,
211	logicalExprOperator: '&&' \| '\|\|'
212	) {
213	const firstExpr = emitOperand(ast, identifier, firstOperandIdentifier, staticContext);	3,975✔
214	if (!firstExpr.isAstAccepted) {	3,975✔
215	return firstExpr;	3,942✔
216	}
217
218	const secondExpr = emitOperand(ast, identifier, secondOperandIdentifier, staticContext);	33✔
219	if (!secondExpr.isAstAccepted) {	33✔
220	return secondExpr;	12✔
221	}
222
223	const andOpCode = `	21✔
224	function ${identifier}(contextItem) {
225	${firstExpr.variables.join('\n')}
226	${secondExpr.variables.join('\n')}
227	return ${firstExpr.code} ${logicalExprOperator} ${secondExpr.code}
228	}
229	`;
230	return acceptAst(andOpCode);	21✔
231	}
232
233	// Compile AST to base expression contained in a function named as the given
234	// identifier.
235	export function emitBaseExpr(	15✔
236	ast: IAST,
237	identifier: FunctionIdentifier,
238	staticContext: StaticContext
239	): PartialCompilationResult {
240	const name = ast[0];	48,159✔
241
242	switch (name) {	48,159✔
243	case baseExprAstNodes.PATH_EXPR:	48,159✔
244	return emitPathExpr(ast, identifier, staticContext);	2,217✔
245	case baseExprAstNodes.AND_OP:
246	return emitAndExpr(ast, identifier, staticContext);	2,967✔
247	case baseExprAstNodes.OR_OP:
248	return emitOrExpr(ast, identifier, staticContext);	1,008✔
249	default:
250	return rejectAst(`Unsupported: the base expression '${name}'.`);	41,967✔
251	}
252	}

FontoXML / fontoxpath / 874864331

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