623964011

Build Type

push

github

Committed by GitHub

Commit Message

Function name resolver

Run Details

4742 of 5123 branches covered (92.56%)

Branch coverage included in aggregate %.

81 of 81 new or added lines in 24 files covered. (100.0%)

1 existing line in 1 file now uncovered.

9142 of 9447 relevant lines covered (96.77%)

1251634.24 hits per line

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

69.91

/src/expressions/functions/builtInFunctions_fontoxpath.ts

import astHelper from '../../parsing/astHelper';
import compileAstToExpression from '../../parsing/compileAstToExpression';
import parseExpression from '../../parsing/parseExpression';
import processProlog from '../../parsing/processProlog';
import createAtomicValue from '../dataTypes/createAtomicValue';
import createPointerValue from '../dataTypes/createPointerValue';
import MapValue from '../dataTypes/MapValue';
import sequenceFactory from '../dataTypes/sequenceFactory';
import Value from '../dataTypes/Value';
import DynamicContext from '../DynamicContext';
import ExecutionSpecificStaticContext from '../ExecutionSpecificStaticContext';
import { FONTOXPATH_NAMESPACE_URI, FUNCTIONS_NAMESPACE_URI } from '../staticallyKnownNamespaces';
import StaticContext from '../StaticContext';
import createDoublyIterableSequence from '../util/createDoublyIterableSequence';
import { DONE_TOKEN, IAsyncIterator, IterationHint, notReady, ready } from '../util/iterators';
import FunctionDefinitionType from './FunctionDefinitionType';

const fontoxpathEvaluate: FunctionDefinitionType = (
        _dynamicContext,
        executionParameters,
        staticContext,
        query,
        args
) => {
        let resultIterator: IAsyncIterator<Value>;
        let queryString: string;
        return sequenceFactory.create({
                next: () => {
                        if (!resultIterator) {
                                const queryValue = query.value.next(IterationHint.NONE);
                                if (!queryValue.ready) {
                                        return queryValue;
                                }
                                queryString = queryValue.value.value;
                                const variables = (args.first() as MapValue).keyValuePairs.reduce(
                                        (expandedArgs, arg) => {
                                                expandedArgs[arg.key.value] = createDoublyIterableSequence(arg.value());
                                                return expandedArgs;
                                        },
                                        Object.create(null)
                                );

                                // Take off the context item
                                const contextItemSequence = variables['.']
                                        ? variables['.']()
                                        : sequenceFactory.empty();
                                delete variables['.'];

                                const executionSpecificStaticContext = new ExecutionSpecificStaticContext(
                                        (prefix) => staticContext.resolveNamespace(prefix),
                                        Object.keys(variables).reduce((vars, varName) => {
                                                vars[varName] = varName;
                                                return vars;
                                        }, {}),
                                        FUNCTIONS_NAMESPACE_URI,
                                        (lexicalName, arity) => staticContext.resolveFunctionName(lexicalName, arity)
                                );
                                const innerStaticContext = new StaticContext(executionSpecificStaticContext);

                                const ast = parseExpression(queryString, { allowXQuery: false });

                                const prolog = astHelper.followPath(ast, ['mainModule', 'prolog']);
                                if (prolog) {
                                        processProlog(prolog, innerStaticContext);
                                }
                                const queryBodyContents = astHelper.followPath(ast, [
                                        'mainModule',
                                        'queryBody',
                                        '*',
                                ]);

                                const selector = compileAstToExpression(queryBodyContents, {
                                        allowUpdating: false,
                                        allowXQuery: true,
                                });

                                selector.performStaticEvaluation(innerStaticContext);

                                const variableBindings = Object.keys(variables).reduce(
                                        (variablesByBindingKey, varName) => {
                                                variablesByBindingKey[
                                                        executionSpecificStaticContext.lookupVariable(null, varName)
                                                ] = variables[varName];
                                                return variablesByBindingKey;
                                        },
                                        Object.create(null)
                                );

                                const context = contextItemSequence.isEmpty()
                                        ? {
                                                        contextItem: null,
                                                        contextItemIndex: -1,
                                                        contextSequence: contextItemSequence,
                                                        variableBindings,
                                          }
                                        : {
                                                        contextItem: contextItemSequence.first(),
                                                        contextItemIndex: 0,
                                                        contextSequence: contextItemSequence,
                                                        variableBindings,
                                          };

                                const innerDynamicContext = new DynamicContext(context);

                                resultIterator = selector.evaluate(innerDynamicContext, executionParameters).value;
                        }
                        return resultIterator.next(IterationHint.NONE);
                },
        });
};

const fontoxpathSleep: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        val,
        howLong
) => {
        let doneWithSleep = false;
        let readyPromise: Promise<void>;

        const valueIterator = val.value;
        return sequenceFactory.create({
                next: (hint: IterationHint) => {
                        if (!readyPromise) {
                                const time = howLong
                                        ? howLong.tryGetFirst()
                                        : ready(createAtomicValue(0, 'xs:integer'));
                                if (!time.ready) {
                                        return notReady(readyPromise);
                                }
                                readyPromise = new Promise((resolve) =>
                                        setTimeout(() => {
                                                doneWithSleep = true;
                                                resolve();
                                        }, time.value.value)
                                );
                        }
                        if (!doneWithSleep) {
                                return notReady(readyPromise);
                        }
                        return valueIterator.next(hint);
                },
        });
};

declare const VERSION: string | undefined;

const fontoxpathVersion: FunctionDefinitionType = () => {
        let version: string;
        // TODO: Refactor when https://github.com/google/closure-compiler/issues/1601 is fixed
        version = typeof VERSION === 'undefined' ? 'devbuild' : VERSION;
        return sequenceFactory.singleton(createAtomicValue(version, 'xs:string'));
};

// TODO: implement a domparser instead of using the global one from the browser
declare var DOMParser;
declare var fetch;

const fontoxpathFetch: FunctionDefinitionType = (
        _dynamicContext,
        executionParameters,
        _staticContext,
        url
) => {
        let doneWithFetch = false;
        let result = null;
        let done = false;
        let readyPromise = null;

        return sequenceFactory.create({
                next: () => {
                        if (!readyPromise) {
                                const urlValue = url.value.next(IterationHint.NONE);
                                if (!urlValue.ready) {
                                        return urlValue;
                                }

                                readyPromise = fetch(urlValue.value.value)
                                        .then((response) => response.text())
                                        .then((text) => new DOMParser().parseFromString(text, 'application/xml'))
                                        .then((doc) => {
                                                doneWithFetch = true;
                                                result = doc;
                                        });
                        }
                        if (!doneWithFetch) {
                                return notReady(readyPromise);
                        }
                        if (!done) {
                                done = true;
                                return ready(createPointerValue(result, executionParameters.domFacade));
                        }
                        return DONE_TOKEN;
                },
        });
};

export default {
        declarations: [
                {
                        argumentTypes: ['xs:string', 'map(*)'],
                        callFunction: fontoxpathEvaluate,
                        localName: 'evaluate',
                        namespaceURI: FONTOXPATH_NAMESPACE_URI,
                        returnType: 'item()*',
                },
                {
                        argumentTypes: ['item()*', 'xs:numeric'],
                        callFunction: fontoxpathSleep,
                        localName: 'sleep',
                        namespaceURI: FONTOXPATH_NAMESPACE_URI,
                        returnType: 'item()*',
                },
                {
                        argumentTypes: ['item()*'],
                        callFunction: fontoxpathSleep,
                        localName: 'sleep',
                        namespaceURI: FONTOXPATH_NAMESPACE_URI,
                        returnType: 'item()*',
                },
                {
                        argumentTypes: ['xs:string', 'map(*)'],
                        callFunction: fontoxpathFetch,
                        localName: 'fetch',
                        namespaceURI: FONTOXPATH_NAMESPACE_URI,
                        returnType: 'item()*',
                },
                {
                        argumentTypes: ['xs:string'],
                        callFunction: fontoxpathFetch,
                        localName: 'fetch',
                        namespaceURI: FONTOXPATH_NAMESPACE_URI,
                        returnType: 'item()*',
                },
                {
                        argumentTypes: [],
                        callFunction: fontoxpathVersion,
                        localName: 'version',
                        namespaceURI: FONTOXPATH_NAMESPACE_URI,
                        returnType: 'xs:string',
                },
        ],
};

1	import astHelper from '../../parsing/astHelper';	5✔
2	import compileAstToExpression from '../../parsing/compileAstToExpression';	5✔
3	import parseExpression from '../../parsing/parseExpression';	5✔
4	import processProlog from '../../parsing/processProlog';	5✔
5	import createAtomicValue from '../dataTypes/createAtomicValue';	5✔
6	import createPointerValue from '../dataTypes/createPointerValue';	5✔
7	import MapValue from '../dataTypes/MapValue';
8	import sequenceFactory from '../dataTypes/sequenceFactory';	5✔
9	import Value from '../dataTypes/Value';
10	import DynamicContext from '../DynamicContext';	5✔
11	import ExecutionSpecificStaticContext from '../ExecutionSpecificStaticContext';	5✔
12	import { FONTOXPATH_NAMESPACE_URI, FUNCTIONS_NAMESPACE_URI } from '../staticallyKnownNamespaces';	5✔
13	import StaticContext from '../StaticContext';	5✔
14	import createDoublyIterableSequence from '../util/createDoublyIterableSequence';	5✔
15	import { DONE_TOKEN, IAsyncIterator, IterationHint, notReady, ready } from '../util/iterators';	5✔
16	import FunctionDefinitionType from './FunctionDefinitionType';
17
18	const fontoxpathEvaluate: FunctionDefinitionType = (	5✔
19	_dynamicContext,
20	executionParameters,
21	staticContext,
22	query,
23	args
24	) => {
25	let resultIterator: IAsyncIterator<Value>;
26	let queryString: string;
27	return sequenceFactory.create({	9✔
28	next: () => {
29	if (!resultIterator) {	17✔
30	const queryValue = query.value.next(IterationHint.NONE);	9✔
31	if (!queryValue.ready) {	9!
32	return queryValue;	×
33	}
34	queryString = queryValue.value.value;	9✔
35	const variables = (args.first() as MapValue).keyValuePairs.reduce(	9✔
36	(expandedArgs, arg) => {
37	expandedArgs[arg.key.value] = createDoublyIterableSequence(arg.value());	3✔
38	return expandedArgs;	3✔
39	},
40	Object.create(null)
41	);
42
43	// Take off the context item
44	const contextItemSequence = variables['.']	9✔
45	? variables['.']()	9✔
46	: sequenceFactory.empty();
47	delete variables['.'];	9✔
48
49	const executionSpecificStaticContext = new ExecutionSpecificStaticContext(	9✔
UNCOV 50	(prefix) => staticContext.resolveNamespace(prefix),	×
51	Object.keys(variables).reduce((vars, varName) => {
52	vars[varName] = varName;	2✔
53	return vars;	2✔
54	}, {}),
55	FUNCTIONS_NAMESPACE_URI,
56	(lexicalName, arity) => staticContext.resolveFunctionName(lexicalName, arity)	9✔
57	);
58	const innerStaticContext = new StaticContext(executionSpecificStaticContext);	9✔
59
60	const ast = parseExpression(queryString, { allowXQuery: false });	9✔
61
62	const prolog = astHelper.followPath(ast, ['mainModule', 'prolog']);	9✔
63	if (prolog) {	9✔
64	processProlog(prolog, innerStaticContext);	1✔
65	}
66	const queryBodyContents = astHelper.followPath(ast, [	9✔
67	'mainModule',
68	'queryBody',
69	'*',
70	]);
71
72	const selector = compileAstToExpression(queryBodyContents, {	9✔
73	allowUpdating: false,
74	allowXQuery: true,
75	});
76
77	selector.performStaticEvaluation(innerStaticContext);	9✔
78
79	const variableBindings = Object.keys(variables).reduce(	9✔
80	(variablesByBindingKey, varName) => {
81	variablesByBindingKey[	2✔
82	executionSpecificStaticContext.lookupVariable(null, varName)
83	] = variables[varName];
84	return variablesByBindingKey;	2✔
85	},
86	Object.create(null)
87	);
88
89	const context = contextItemSequence.isEmpty()	9✔
90	? {	9✔
91	contextItem: null,
92	contextItemIndex: -1,
93	contextSequence: contextItemSequence,
94	variableBindings,
95	}
96	: {
97	contextItem: contextItemSequence.first(),
98	contextItemIndex: 0,
99	contextSequence: contextItemSequence,
100	variableBindings,
101	};
102
103	const innerDynamicContext = new DynamicContext(context);	9✔
104
105	resultIterator = selector.evaluate(innerDynamicContext, executionParameters).value;	9✔
106	}
107	return resultIterator.next(IterationHint.NONE);	17✔
108	},
109	});
110	};
111
112	const fontoxpathSleep: FunctionDefinitionType = (	5✔
113	_dynamicContext,
114	_executionParameters,
115	_staticContext,
116	val,
117	howLong
118	) => {
119	let doneWithSleep = false;	358✔
120	let readyPromise: Promise<void>;
121
122	const valueIterator = val.value;	358✔
123	return sequenceFactory.create({	358✔
124	next: (hint: IterationHint) => {
125	if (!readyPromise) {	6,074✔
126	const time = howLong	356✔
127	? howLong.tryGetFirst()	356✔
128	: ready(createAtomicValue(0, 'xs:integer'));
129	if (!time.ready) {	356!
130	return notReady(readyPromise);	×
131	}
132	readyPromise = new Promise((resolve) =>	356✔
133	setTimeout(() => {	356✔
134	doneWithSleep = true;	356✔
135	resolve();	356✔
136	}, time.value.value)
137	);
138	}
139	if (!doneWithSleep) {	6,074✔
140	return notReady(readyPromise);	452✔
141	}
142	return valueIterator.next(hint);	5,622✔
143	},
144	});
145	};
146
147	declare const VERSION: string \| undefined;
148
149	const fontoxpathVersion: FunctionDefinitionType = () => {	5✔
150	let version: string;
151	// TODO: Refactor when https://github.com/google/closure-compiler/issues/1601 is fixed
152	version = typeof VERSION === 'undefined' ? 'devbuild' : VERSION;	1!
153	return sequenceFactory.singleton(createAtomicValue(version, 'xs:string'));	1✔
154	};
155
156	// TODO: implement a domparser instead of using the global one from the browser
157	declare var DOMParser;
158	declare var fetch;
159
160	const fontoxpathFetch: FunctionDefinitionType = (	5✔
161	_dynamicContext,
162	executionParameters,
163	_staticContext,
164	url
165	) => {
166	let doneWithFetch = false;	×
167	let result = null;	×
168	let done = false;	×
169	let readyPromise = null;	×
170
171	return sequenceFactory.create({	×
172	next: () => {
173	if (!readyPromise) {	×
174	const urlValue = url.value.next(IterationHint.NONE);	×
175	if (!urlValue.ready) {	×
176	return urlValue;	×
177	}
178
179	readyPromise = fetch(urlValue.value.value)	×
180	.then((response) => response.text())	×
181	.then((text) => new DOMParser().parseFromString(text, 'application/xml'))	×
182	.then((doc) => {
183	doneWithFetch = true;	×
184	result = doc;	×
185	});
186	}
187	if (!doneWithFetch) {	×
188	return notReady(readyPromise);	×
189	}
190	if (!done) {	×
191	done = true;	×
192	return ready(createPointerValue(result, executionParameters.domFacade));	×
193	}
194	return DONE_TOKEN;	×
195	},
196	});
197	};
198
199	export default {	5✔
200	declarations: [
201	{
202	argumentTypes: ['xs:string', 'map(*)'],
203	callFunction: fontoxpathEvaluate,
204	localName: 'evaluate',
205	namespaceURI: FONTOXPATH_NAMESPACE_URI,
206	returnType: 'item()*',
207	},
208	{
209	argumentTypes: ['item()*', 'xs:numeric'],
210	callFunction: fontoxpathSleep,
211	localName: 'sleep',
212	namespaceURI: FONTOXPATH_NAMESPACE_URI,
213	returnType: 'item()*',
214	},
215	{
216	argumentTypes: ['item()*'],
217	callFunction: fontoxpathSleep,
218	localName: 'sleep',
219	namespaceURI: FONTOXPATH_NAMESPACE_URI,
220	returnType: 'item()*',
221	},
222	{
223	argumentTypes: ['xs:string', 'map(*)'],
224	callFunction: fontoxpathFetch,
225	localName: 'fetch',
226	namespaceURI: FONTOXPATH_NAMESPACE_URI,
227	returnType: 'item()*',
228	},
229	{
230	argumentTypes: ['xs:string'],
231	callFunction: fontoxpathFetch,
232	localName: 'fetch',
233	namespaceURI: FONTOXPATH_NAMESPACE_URI,
234	returnType: 'item()*',
235	},
236	{
237	argumentTypes: [],
238	callFunction: fontoxpathVersion,
239	localName: 'version',
240	namespaceURI: FONTOXPATH_NAMESPACE_URI,
241	returnType: 'xs:string',
242	},
243	],
244	};

FontoXML / fontoxpath / 623964011

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