1426173918

Build Type

github

Committed by GitHub

Commit Message

Merge 7aaf5ab28 into 74c3958c7

Pull Request Pull Request #439: Eval ast

Run Details

4695 of 5089 branches covered (92.26%)

Branch coverage included in aggregate %.

123 of 135 new or added lines in 23 files covered. (91.11%)

40 existing lines in 3 files now uncovered.

9444 of 9734 relevant lines covered (97.02%)

6144049.58 hits per line

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

83.33

/src/expressions/VarRef.ts

import ISequence from './dataTypes/ISequence';
import DynamicContext from './DynamicContext';
import ExecutionParameters from './ExecutionParameters';
import Expression, { RESULT_ORDERINGS } from './Expression';
import Specificity from './Specificity';
import StaticContext from './StaticContext';

class VarRef extends Expression {
        private _namespaceURI: string;
        private _prefix: string;
        private _staticallyBoundVariableValue: (
                dynamicContext: DynamicContext,
                executionParameters: ExecutionParameters
        ) => ISequence;
        private _variableBindingName: any;
        private _variableName: string;

        constructor(prefix: string, namespaceURI: string | null, variableName: string) {
                super(new Specificity({}), [], {
                        canBeStaticallyEvaluated: false,
                        resultOrder: RESULT_ORDERINGS.UNSORTED,
                });

                this._variableName = variableName;
                this._namespaceURI = namespaceURI || undefined;
                this._prefix = prefix;

                this._variableBindingName = null;
        }

        public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
                const variableBinding = dynamicContext.variableBindings[this._variableBindingName];
                // Make dynamic variables take precedence
                if (!variableBinding) {
                        if (this._staticallyBoundVariableValue) {
                                return this._staticallyBoundVariableValue(dynamicContext, executionParameters);
                        }
                        throw new Error(
                                'XQDY0054: The variable ' + this._variableName + ' is declared but not in scope.'
                        );
                }

                return dynamicContext.variableBindings[this._variableBindingName]();
        }

        public performStaticEvaluation(staticContext: StaticContext) {
                if (this._prefix) {
                        this._namespaceURI = staticContext.resolveNamespace(this._prefix);
                }

                this._variableBindingName = staticContext.lookupVariable(
                        this._namespaceURI || undefined,
                        this._variableName
                );
                if (!this._variableBindingName) {
                        throw new Error('XPST0008, The variable ' + this._variableName + ' is not in scope.');
                }

                const staticallyBoundVariableBinding = staticContext.getVariableDeclaration(
                        this._variableBindingName
                );

                if (staticallyBoundVariableBinding) {
                        this._staticallyBoundVariableValue = staticallyBoundVariableBinding;
                }
        }
}

export default VarRef;

1	import ISequence from './dataTypes/ISequence';
2	import DynamicContext from './DynamicContext';
3	import ExecutionParameters from './ExecutionParameters';
4	import Expression, { RESULT_ORDERINGS } from './Expression';	18✔
5	import Specificity from './Specificity';	18✔
6	import StaticContext from './StaticContext';
7
8	class VarRef extends Expression {
9	private _namespaceURI: string;
10	private _prefix: string;
11	private _staticallyBoundVariableValue: (
12	dynamicContext: DynamicContext,
13	executionParameters: ExecutionParameters
14	) => ISequence;
15	private _variableBindingName: any;
16	private _variableName: string;
17
18	constructor(prefix: string, namespaceURI: string \| null, variableName: string) {
19	super(new Specificity({}), [], {	899,346✔
20	canBeStaticallyEvaluated: false,
21	resultOrder: RESULT_ORDERINGS.UNSORTED,
22	});
23
24	this._variableName = variableName;	899,346✔
25	this._namespaceURI = namespaceURI \|\| undefined;	899,346✔
26	this._prefix = prefix;	899,346✔
27
28	this._variableBindingName = null;	899,346✔
29	}
30
31	public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
32	const variableBinding = dynamicContext.variableBindings[this._variableBindingName];	21,989,433✔
33	// Make dynamic variables take precedence
34	if (!variableBinding) {	21,989,433!
UNCOV 35	if (this._staticallyBoundVariableValue) {	×
UNCOV 36	return this._staticallyBoundVariableValue(dynamicContext, executionParameters);	×
37	}
38	throw new Error(	×
39	'XQDY0054: The variable ' + this._variableName + ' is declared but not in scope.'
40	);
41	}
42
43	return dynamicContext.variableBindings[this._variableBindingName]();	21,989,433✔
44	}
45
46	public performStaticEvaluation(staticContext: StaticContext) {
47	if (this._prefix) {	886,581✔
48	this._namespaceURI = staticContext.resolveNamespace(this._prefix);	309✔
49	}
50
51	this._variableBindingName = staticContext.lookupVariable(	886,581✔
52	this._namespaceURI \|\| undefined,	1,772,793✔
53	this._variableName
54	);
55	if (!this._variableBindingName) {	886,581✔
56	throw new Error('XPST0008, The variable ' + this._variableName + ' is not in scope.');	411✔
57	}
58
59	const staticallyBoundVariableBinding = staticContext.getVariableDeclaration(	886,170✔
60	this._variableBindingName
61	);
62
63	if (staticallyBoundVariableBinding) {	886,170✔
64	this._staticallyBoundVariableValue = staticallyBoundVariableBinding;	2,934✔
65	}
66	}
67	}
68
69	export default VarRef;	18✔

FontoXML / fontoxpath / 1426173918

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