1449338604

Build Type

github

Committed by GitHub

Commit Message

Merge 742898f45 into 208ac2796

Pull Request Pull Request #439: Eval ast

Run Details

4727 of 5118 branches covered (92.36%)

Branch coverage included in aggregate %.

144 of 157 new or added lines in 26 files covered. (91.72%)

40 existing lines in 3 files now uncovered.

9494 of 9782 relevant lines covered (97.06%)

15168518.31 hits per line

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

91.18

/src/expressions/ExecutionSpecificStaticContext.ts

import {
        FunctionNameResolver,
        LexicalQualifiedName,
        ResolvedQualifiedName,
} from '../types/Options';
import IContext from './Context';
import ISequence from './dataTypes/ISequence';
import DynamicContext from './DynamicContext';
import ExecutionParameters from './ExecutionParameters';
import { FunctionProperties, getFunctionByArity } from './functions/functionRegistry';
import { staticallyKnownNamespaceByPrefix } from './staticallyKnownNamespaces';

const generateGlobalVariableBindingName = (variableName: string) => `Q{}${variableName}[0]`;

export type ResolvedFunction = {
        arity: number;
        lexicalQName: LexicalQualifiedName;
        resolvedQName: ResolvedQualifiedName;
};

/**
 * XPaths in FontoXPath know of two separate contexts: the static one and the context at evaluation.
 *
 * Because FontoXPath allows injecting variables and namespace declarations at evaluation time,
 * static compilation _may_ depend on evaluation context.
 *
 * If it does, this execution context will be used to mark the statically compiled selector as
 * specific for the evaluation context. If the XPath did not depend on the evaluation context, it
 * will be reused.
 */
export default class ExecutionSpecificStaticContext implements IContext {
        public executionContextWasRequired: boolean;
        public registeredDefaultFunctionNamespaceURI: string | null;
        public registeredVariableBindingByHashKey: { [s: string]: string }[] = [Object.create(null)];
        public registeredVariableDeclarationByHashKey: {
                [hash: string]: (
                        dynamicContext: DynamicContext,
                        executionParameters: ExecutionParameters
                ) => ISequence;
        } = Object.create(null);

        private _functionNameResolver: FunctionNameResolver;
        private _namespaceResolver: (namespaceURI: string) => null | string;

        // The static compilation step depends on the prefix -> namespaceURI pairs in the namespace resolver
        private _referredNamespaceByName: {
                [prefix: string]: { namespaceURI: string; prefix: string };
        };
        // And the ABSENCE of variables: a statically compiled XPath does not compile the same when external variables are absent in the calling code.
        private _referredVariableByName: {
                [variable: string]: { name: string };
        };

        private _resolvedFunctions: ResolvedFunction[];

        private _variableBindingByName: { [variableName: string]: string };

        constructor(
                namespaceResolver: (prefix: string) => string | null,
                variableByName: { [varName: string]: any },
                defaultFunctionNamespaceURI: string,
                functionNameResolver: FunctionNameResolver
        ) {
                this._namespaceResolver = namespaceResolver;

                this._variableBindingByName = Object.keys(variableByName).reduce(
                        (bindings: { [varName: string]: string }, variableName) => {
                                if (variableByName[variableName] === undefined) {
                                        return bindings;
                                }
                                bindings[variableName] = generateGlobalVariableBindingName(variableName);
                                return bindings;
                        },
                        Object.create(null)
                );

                this._referredVariableByName = Object.create(null);
                this._referredNamespaceByName = Object.create(null);

                this.registeredDefaultFunctionNamespaceURI = defaultFunctionNamespaceURI;

                this._functionNameResolver = functionNameResolver;

                this._resolvedFunctions = [];

                /**
                 * This flag will be set to true if this EvaluationContext was used while statically
                 * compiling a Expression
                 */
                this.executionContextWasRequired = false;
        }

        public getReferredNamespaces(): { namespaceURI: string; prefix: string }[] {
                return Object.values(this._referredNamespaceByName);
        }

        public getReferredVariables(): { name: string }[] {
                return Object.values(this._referredVariableByName);
        }

        public getResolvedFunctions(): ResolvedFunction[] {
                return this._resolvedFunctions;
        }

        public lookupFunction(
                namespaceURI: string,
                localName: string,
                arity: number,
                _skipExternal: boolean
        ): FunctionProperties | null {
                // It is impossible to inject functions at execution time, so we can always return a globally defined one.
                return getFunctionByArity(namespaceURI, localName, arity);
        }

        public lookupVariable(namespaceURI: string, localName: string) {
                this.executionContextWasRequired = true;

                if (namespaceURI) {
                        return null;
                }

                const bindingName = this._variableBindingByName[localName];
                if (!this._referredVariableByName[localName]) {
                        this._referredVariableByName[localName] = {
                                name: localName,
                        };
                }
                return bindingName;
        }

        public resolveFunctionName(
                lexicalQName: LexicalQualifiedName,
                arity: number
        ): ResolvedQualifiedName {
                const resolvedQName = this._functionNameResolver(lexicalQName, arity);

                if (resolvedQName) {
                        this._resolvedFunctions.push({
                                lexicalQName,
                                arity,
                                resolvedQName,
                        });
                } else {
                        // Maybe the namespaceResolver can shine some light:
                        const namespaceURI = this.resolveNamespace(lexicalQName.prefix, true);
                        if (namespaceURI) {
                                return {
                                        namespaceURI,
                                        localName: lexicalQName.localName,
                                };
                        }
                }

                return resolvedQName;
        }

        public resolveNamespace(prefix: string, useExternalResolver: boolean = true) {
                if (!useExternalResolver) {
                        // For function lookups, do not go to the outside to resolve a function namespace uri
                        // There is separate config especially for that
                        return null;
                }
                // See if it 'globally' known:
                if (staticallyKnownNamespaceByPrefix[prefix]) {
                        return staticallyKnownNamespaceByPrefix[prefix];
                }
                this.executionContextWasRequired = true;

                const uri = this._namespaceResolver(prefix);

                if (!this._referredNamespaceByName[prefix]) {
                        this._referredNamespaceByName[prefix] = {
                                namespaceURI: uri,
                                prefix,
                        };
                }

                if (uri === undefined && !prefix) {
                        return null;
                }

                return uri;
        }
}

1	import {
2	FunctionNameResolver,
3	LexicalQualifiedName,
4	ResolvedQualifiedName,
5	} from '../types/Options';
6	import IContext from './Context';
7	import ISequence from './dataTypes/ISequence';
8	import DynamicContext from './DynamicContext';
9	import ExecutionParameters from './ExecutionParameters';
10	import { FunctionProperties, getFunctionByArity } from './functions/functionRegistry';	30✔
11	import { staticallyKnownNamespaceByPrefix } from './staticallyKnownNamespaces';	30✔
12
13	const generateGlobalVariableBindingName = (variableName: string) => `Q{}${variableName}[0]`;	2,908,705✔
14
15	export type ResolvedFunction = {
16	arity: number;
17	lexicalQName: LexicalQualifiedName;
18	resolvedQName: ResolvedQualifiedName;
19	};
20
21	/**
22	* XPaths in FontoXPath know of two separate contexts: the static one and the context at evaluation.
23	*
24	* Because FontoXPath allows injecting variables and namespace declarations at evaluation time,
25	* static compilation _may_ depend on evaluation context.
26	*
27	* If it does, this execution context will be used to mark the statically compiled selector as
28	* specific for the evaluation context. If the XPath did not depend on the evaluation context, it
29	* will be reused.
30	*/
31	export default class ExecutionSpecificStaticContext implements IContext {	30✔
32	public executionContextWasRequired: boolean;
33	public registeredDefaultFunctionNamespaceURI: string \| null;
34	public registeredVariableBindingByHashKey: { [s: string]: string }[] = [Object.create(null)];	5,911,435✔
35	public registeredVariableDeclarationByHashKey: {	5,911,435✔
36	[hash: string]: (
37	dynamicContext: DynamicContext,
38	executionParameters: ExecutionParameters
39	) => ISequence;
40	} = Object.create(null);
41
42	private _functionNameResolver: FunctionNameResolver;
43	private _namespaceResolver: (namespaceURI: string) => null \| string;
44
45	// The static compilation step depends on the prefix -> namespaceURI pairs in the namespace resolver
46	private _referredNamespaceByName: {
47	[prefix: string]: { namespaceURI: string; prefix: string };
48	};
49	// And the ABSENCE of variables: a statically compiled XPath does not compile the same when external variables are absent in the calling code.
50	private _referredVariableByName: {
51	[variable: string]: { name: string };
52	};
53
54	private _resolvedFunctions: ResolvedFunction[];
55
56	private _variableBindingByName: { [variableName: string]: string };
57
58	constructor(
59	namespaceResolver: (prefix: string) => string \| null,
60	variableByName: { [varName: string]: any },
61	defaultFunctionNamespaceURI: string,
62	functionNameResolver: FunctionNameResolver
63	) {
64	this._namespaceResolver = namespaceResolver;	5,911,435✔
65
66	this._variableBindingByName = Object.keys(variableByName).reduce(	5,911,435✔
67	(bindings: { [varName: string]: string }, variableName) => {
68	if (variableByName[variableName] === undefined) {	2,908,705!
69	return bindings;	×
70	}
71	bindings[variableName] = generateGlobalVariableBindingName(variableName);	2,908,705✔
72	return bindings;	2,908,705✔
73	},
74	Object.create(null)
75	);
76
77	this._referredVariableByName = Object.create(null);	5,911,435✔
78	this._referredNamespaceByName = Object.create(null);	5,911,435✔
79
80	this.registeredDefaultFunctionNamespaceURI = defaultFunctionNamespaceURI;	5,911,435✔
81
82	this._functionNameResolver = functionNameResolver;	5,911,435✔
83
84	this._resolvedFunctions = [];	5,911,435✔
85
86	/**
87	* This flag will be set to true if this EvaluationContext was used while statically
88	* compiling a Expression
89	*/
90	this.executionContextWasRequired = false;	5,911,435✔
91	}
92
93	public getReferredNamespaces(): { namespaceURI: string; prefix: string }[] {
UNCOV 94	return Object.values(this._referredNamespaceByName);	×
95	}
96
97	public getReferredVariables(): { name: string }[] {
UNCOV 98	return Object.values(this._referredVariableByName);	×
99	}
100
101	public getResolvedFunctions(): ResolvedFunction[] {
UNCOV 102	return this._resolvedFunctions;	×
103	}
104
105	public lookupFunction(
106	namespaceURI: string,
107	localName: string,
108	arity: number,
109	_skipExternal: boolean
110	): FunctionProperties \| null {
111	// It is impossible to inject functions at execution time, so we can always return a globally defined one.
112	return getFunctionByArity(namespaceURI, localName, arity);	6,339,825✔
113	}
114
115	public lookupVariable(namespaceURI: string, localName: string) {
116	this.executionContextWasRequired = true;	478,670✔
117
118	if (namespaceURI) {	478,670✔
119	return null;	60✔
120	}
121
122	const bindingName = this._variableBindingByName[localName];	478,610✔
123	if (!this._referredVariableByName[localName]) {	478,610✔
124	this._referredVariableByName[localName] = {	477,020✔
125	name: localName,
126	};
127	}
128	return bindingName;	478,610✔
129	}
130
131	public resolveFunctionName(
132	lexicalQName: LexicalQualifiedName,
133	arity: number
134	): ResolvedQualifiedName {
135	const resolvedQName = this._functionNameResolver(lexicalQName, arity);	5,454,870✔
136
137	if (resolvedQName) {	5,454,870✔
138	this._resolvedFunctions.push({	3,685,915✔
139	lexicalQName,
140	arity,
141	resolvedQName,
142	});
143	} else {
144	// Maybe the namespaceResolver can shine some light:
145	const namespaceURI = this.resolveNamespace(lexicalQName.prefix, true);	1,768,955✔
146	if (namespaceURI) {	1,768,955✔
147	return {	1,747,875✔
148	namespaceURI,
149	localName: lexicalQName.localName,
150	};
151	}
152	}
153
154	return resolvedQName;	3,706,995✔
155	}
156
157	public resolveNamespace(prefix: string, useExternalResolver: boolean = true) {	×
158	if (!useExternalResolver) {	18,338,510✔
159	// For function lookups, do not go to the outside to resolve a function namespace uri
160	// There is separate config especially for that
161	return null;	1,784,820✔
162	}
163	// See if it 'globally' known:
164	if (staticallyKnownNamespaceByPrefix[prefix]) {	16,553,690✔
165	return staticallyKnownNamespaceByPrefix[prefix];	1,785,085✔
166	}
167	this.executionContextWasRequired = true;	14,768,605✔
168
169	const uri = this._namespaceResolver(prefix);	14,768,605✔
170
171	if (!this._referredNamespaceByName[prefix]) {	14,768,605✔
172	this._referredNamespaceByName[prefix] = {	4,879,525✔
173	namespaceURI: uri,
174	prefix,
175	};
176	}
177
178	if (uri === undefined && !prefix) {	14,768,605✔
179	return null;	5,780✔
180	}
181
182	return uri;	14,762,825✔
183	}
184	}

FontoXML / fontoxpath / 1449338604

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