863975810

Build Type

github

Committed by GitHub

Commit Message

Merge 601703283 into 771b6345b

Pull Request Pull Request #325: Implement JavaScript code generation

Run Details

4408 of 4744 branches covered (92.92%)

Branch coverage included in aggregate %.

245 of 249 new or added lines in 12 files covered. (98.39%)

2 existing lines in 2 files now uncovered.

8636 of 8877 relevant lines covered (97.29%)

3744582.25 hits per line

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

96.81

/src/expressions/path/PathExpression.ts

import DomFacade from '../../domFacade/DomFacade';
import { sortNodeValues } from '../dataTypes/documentOrderUtils';
import ISequence from '../dataTypes/ISequence';
import isSubtypeOf from '../dataTypes/isSubtypeOf';
import sequenceFactory from '../dataTypes/sequenceFactory';
import Value, { ValueType } from '../dataTypes/Value';
import DynamicContext from '../DynamicContext';
import ExecutionParameters from '../ExecutionParameters';
import Expression, { RESULT_ORDERINGS } from '../Expression';
import Specificity from '../Specificity';
import createSingleValueIterator from '../util/createSingleValueIterator';
import { DONE_TOKEN, IIterator, IterationHint, ready } from '../util/iterators';
import { concatSortedSequences, mergeSortedSequences } from '../util/sortedSequenceUtils';

function sortResults(domFacade: DomFacade, result: Value[]) {
        let resultContainsNodes = false;
        let resultContainsNonNodes = false;
        result.forEach((resultValue) => {
                if (isSubtypeOf(resultValue.type, ValueType.NODE)) {
                        resultContainsNodes = true;
                } else {
                        resultContainsNonNodes = true;
                }
        });
        if (resultContainsNonNodes && resultContainsNodes) {
                throw new Error(
                        'XPTY0018: The path operator should either return nodes or non-nodes. Mixed sequences are not allowed.'
                );
        }

        if (resultContainsNodes) {
                return sortNodeValues(domFacade, result);
        }
        return result;
}

class PathExpression extends Expression {
        private _requireSortedResults: boolean;
        private _stepExpressions: Expression[];

        constructor(stepExpressions: Expression[], requireSortedResults: boolean) {
                const pathResultsInPeerSequence = stepExpressions.every((selector) => selector.peer);
                const pathResultsInSubtreeSequence = stepExpressions.every((selector) => selector.subtree);
                super(
                        stepExpressions.reduce((specificity, selector) => {
                                // Implicit AND, so sum
                                return specificity.add(selector.specificity);
                        }, new Specificity({})),
                        stepExpressions,
                        {
                                canBeStaticallyEvaluated: false,
                                peer: pathResultsInPeerSequence,
                                resultOrder: requireSortedResults
                                        ? RESULT_ORDERINGS.SORTED
                                        : RESULT_ORDERINGS.UNSORTED,
                                subtree: pathResultsInSubtreeSequence,
                        }
                );

                this._stepExpressions = stepExpressions;
                this._requireSortedResults = requireSortedResults;
        }

        public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
                let sequenceHasPeerProperty = true;
                const result = this._stepExpressions.reduce<ISequence>(
                        (intermediateResultNodesSequence, selector, index) => {
                                let childContextIterator: IIterator<DynamicContext>;
                                if (intermediateResultNodesSequence === null) {
                                        // first call, we should use the current dynamic context
                                        childContextIterator = createSingleValueIterator(dynamicContext);
                                } else {
                                        childContextIterator = dynamicContext.createSequenceIterator(
                                                intermediateResultNodesSequence
                                        );
                                }
                                let resultValuesInOrderOfEvaluation: IIterator<ISequence> = {
                                        next: (hint: IterationHint) => {
                                                const childContext = childContextIterator.next(hint);

                                                if (childContext.done) {
                                                        return DONE_TOKEN;
                                                }
                                                if (
                                                        childContext.value.contextItem !== null &&
                                                        !isSubtypeOf(childContext.value.contextItem.type, ValueType.NODE)
                                                ) {
                                                        if (index > 0) {
                                                                // The result comes from the first expression: that's not allowed:
                                                                // XPTY0019.

                                                                // If the result comes from the zero-th expression, it is coming
                                                                // from outside. In that case, the axis step is supposed to error
                                                                // with XPTY0020
                                                                throw new Error(
                                                                        'XPTY0019: The result of E1 in a path expression E1/E2 should not evaluate to a sequence of nodes.'
                                                                );
                                                        }
                                                }
                                                return ready(
                                                        selector.evaluateMaybeStatically(
                                                                childContext.value,
                                                                executionParameters
                                                        )
                                                );
                                        },
                                };
                                // Assume nicely sorted
                                let sortedResultSequence: ISequence;
                                if (!this._requireSortedResults) {
                                        sortedResultSequence = concatSortedSequences(resultValuesInOrderOfEvaluation);
                                } else {
                                        switch (selector.expectedResultOrder) {
                                                case RESULT_ORDERINGS.REVERSE_SORTED: {
                                                        const resultValuesInReverseOrder = resultValuesInOrderOfEvaluation;
                                                        resultValuesInOrderOfEvaluation = {
                                                                next: (hint: IterationHint) => {
                                                                        const res = resultValuesInReverseOrder.next(hint);
                                                                        if (res.done) {
                                                                                return res;
                                                                        }
                                                                        return ready(
                                                                                res.value.mapAll((items) =>
                                                                                        sequenceFactory.create(items.reverse())
                                                                                )
                                                                        );
                                                                },
                                                        };
                                                        // Fallthrough for merges
                                                }
                                                case RESULT_ORDERINGS.SORTED:
                                                        if (selector.subtree && sequenceHasPeerProperty) {
                                                                sortedResultSequence = concatSortedSequences(
                                                                        resultValuesInOrderOfEvaluation
                                                                );
                                                                break;
                                                        }
                                                        // Only locally sorted
                                                        sortedResultSequence = mergeSortedSequences(
                                                                executionParameters.domFacade,
                                                                resultValuesInOrderOfEvaluation
                                                        );
                                                        break;
                                                case RESULT_ORDERINGS.UNSORTED: {
                                                        // The result should be sorted before we can continue
                                                        const concattedSequence = concatSortedSequences(
                                                                resultValuesInOrderOfEvaluation
                                                        );
                                                        return concattedSequence.mapAll((allValues) =>
                                                                sequenceFactory.create(
                                                                        sortResults(executionParameters.domFacade, allValues)
                                                                )
                                                        );
                                                }
                                        }
                                }
                                // If this selector returned non-peers, the sequence could be contaminated with ancestor/descendant nodes
                                // This makes sorting using concat impossible
                                sequenceHasPeerProperty = sequenceHasPeerProperty && selector.peer;
                                return sortedResultSequence;
                        },
                        null
                );

                return result;
        }

        public getBucket() {
                return this._stepExpressions[0].getBucket();
        }
}

export default PathExpression;

1	import DomFacade from '../../domFacade/DomFacade';
2	import { sortNodeValues } from '../dataTypes/documentOrderUtils';	15✔
3	import ISequence from '../dataTypes/ISequence';
4	import isSubtypeOf from '../dataTypes/isSubtypeOf';	15✔
5	import sequenceFactory from '../dataTypes/sequenceFactory';	15✔
6	import Value, { ValueType } from '../dataTypes/Value';
7	import DynamicContext from '../DynamicContext';
8	import ExecutionParameters from '../ExecutionParameters';
9	import Expression, { RESULT_ORDERINGS } from '../Expression';	15✔
10	import Specificity from '../Specificity';	15✔
11	import createSingleValueIterator from '../util/createSingleValueIterator';	15✔
12	import { DONE_TOKEN, IIterator, IterationHint, ready } from '../util/iterators';	15✔
13	import { concatSortedSequences, mergeSortedSequences } from '../util/sortedSequenceUtils';	15✔
14
15	function sortResults(domFacade: DomFacade, result: Value[]) {
16	let resultContainsNodes = false;	10,612,185✔
17	let resultContainsNonNodes = false;	10,612,185✔
18	result.forEach((resultValue) => {	10,612,185✔
19	if (isSubtypeOf(resultValue.type, ValueType.NODE)) {	9,429,360✔
20	resultContainsNodes = true;	9,169,401✔
21	} else {
22	resultContainsNonNodes = true;	259,959✔
23	}
24	});
25	if (resultContainsNonNodes && resultContainsNodes) {	10,612,185✔
26	throw new Error(	45✔
27	'XPTY0018: The path operator should either return nodes or non-nodes. Mixed sequences are not allowed.'
28	);
29	}
30
31	if (resultContainsNodes) {	10,612,140✔
32	return sortNodeValues(domFacade, result);	9,141,426✔
33	}
34	return result;	1,470,714✔
35	}
36
37	class PathExpression extends Expression {
38	private _requireSortedResults: boolean;
39	private _stepExpressions: Expression[];
40
41	constructor(stepExpressions: Expression[], requireSortedResults: boolean) {
42	const pathResultsInPeerSequence = stepExpressions.every((selector) => selector.peer);	29,790✔
43	const pathResultsInSubtreeSequence = stepExpressions.every((selector) => selector.subtree);	32,547✔
44	super(	22,194✔
45	stepExpressions.reduce((specificity, selector) => {
46	// Implicit AND, so sum
47	return specificity.add(selector.specificity);	57,792✔
48	}, new Specificity({})),
49	stepExpressions,
50	{
51	canBeStaticallyEvaluated: false,
52	peer: pathResultsInPeerSequence,
53	resultOrder: requireSortedResults
54	? RESULT_ORDERINGS.SORTED	22,194!
55	: RESULT_ORDERINGS.UNSORTED,
56	subtree: pathResultsInSubtreeSequence,
57	}
58	);
59
60	this._stepExpressions = stepExpressions;	22,194✔
61	this._requireSortedResults = requireSortedResults;	22,194✔
62	}
63
64	public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
65	let sequenceHasPeerProperty = true;	7,489,143✔
66	const result = this._stepExpressions.reduce<ISequence>(	7,489,143✔
67	(intermediateResultNodesSequence, selector, index) => {
68	let childContextIterator: IIterator<DynamicContext>;
69	if (intermediateResultNodesSequence === null) {	17,991,684✔
70	// first call, we should use the current dynamic context
71	childContextIterator = createSingleValueIterator(dynamicContext);	7,489,143✔
72	} else {
73	childContextIterator = dynamicContext.createSequenceIterator(	10,502,541✔
74	intermediateResultNodesSequence
75	);
76	}
77	let resultValuesInOrderOfEvaluation: IIterator<ISequence> = {	17,991,684✔
78	next: (hint: IterationHint) => {
79	const childContext = childContextIterator.next(hint);	61,350,876✔
80
81	if (childContext.done) {	61,350,876✔
82	return DONE_TOKEN;	17,677,146✔
83	}
84	if (	43,673,730✔
85	childContext.value.contextItem !== null &&	87,304,173✔
86	!isSubtypeOf(childContext.value.contextItem.type, ValueType.NODE)
87	) {
88	if (index > 0) {	102✔
89	// The result comes from the first expression: that's not allowed:
90	// XPTY0019.
91
92	// If the result comes from the zero-th expression, it is coming
93	// from outside. In that case, the axis step is supposed to error
94	// with XPTY0020
95	throw new Error(	51✔
96	'XPTY0019: The result of E1 in a path expression E1/E2 should not evaluate to a sequence of nodes.'
97	);
98	}
99	}
100	return ready(	43,673,679✔
101	selector.evaluateMaybeStatically(
102	childContext.value,
103	executionParameters
104	)
105	);
106	},
107	};
108	// Assume nicely sorted
109	let sortedResultSequence: ISequence;
110	if (!this._requireSortedResults) {	17,991,684!
UNCOV 111	sortedResultSequence = concatSortedSequences(resultValuesInOrderOfEvaluation);	×
112	} else {
113	switch (selector.expectedResultOrder) {	17,991,684✔
114	case RESULT_ORDERINGS.REVERSE_SORTED: {	18,168,216✔
115	const resultValuesInReverseOrder = resultValuesInOrderOfEvaluation;	176,532✔
116	resultValuesInOrderOfEvaluation = {	176,532✔
117	next: (hint: IterationHint) => {
118	const res = resultValuesInReverseOrder.next(hint);	353,643✔
119	if (res.done) {	353,595✔
120	return res;	176,475✔
121	}
122	return ready(	177,120✔
123	res.value.mapAll((items) =>
124	sequenceFactory.create(items.reverse())	177,120✔
125	)
126	);
127	},
128	};
129	// Fallthrough for merges
130	}
131	case RESULT_ORDERINGS.SORTED:
132	if (selector.subtree && sequenceHasPeerProperty) {	7,379,457✔
133	sortedResultSequence = concatSortedSequences(	5,181,186✔
134	resultValuesInOrderOfEvaluation
135	);
136	break;	5,181,156✔
137	}
138	// Only locally sorted
139	sortedResultSequence = mergeSortedSequences(	2,198,271✔
140	executionParameters.domFacade,
141	resultValuesInOrderOfEvaluation
142	);
143	break;	2,198,181✔
144	case RESULT_ORDERINGS.UNSORTED: {
145	// The result should be sorted before we can continue
146	const concattedSequence = concatSortedSequences(	10,612,227✔
147	resultValuesInOrderOfEvaluation
148	);
149	return concattedSequence.mapAll((allValues) =>	10,612,191✔
150	sequenceFactory.create(	10,612,185✔
151	sortResults(executionParameters.domFacade, allValues)
152	)
153	);
154	}
155	}
156	}
157	// If this selector returned non-peers, the sequence could be contaminated with ancestor/descendant nodes
158	// This makes sorting using concat impossible
159	sequenceHasPeerProperty = sequenceHasPeerProperty && selector.peer;	7,379,337✔
160	return sortedResultSequence;	7,379,337✔
161	},
162	null
163	);
164
165	return result;	7,488,936✔
166	}
167
168	public getBucket() {
169	return this._stepExpressions[0].getBucket();	129,885✔
170	}
171	}
172
173	export default PathExpression;	15✔

FontoXML / fontoxpath / 863975810

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