893119273

Build # 893119273

Build Type

github

Committed by GitHub

Commit Message

Merge 146026115 into 154cb0a16

Pull Request Pull Request #357: WIP: Type inference

Run Details

4411 of 4761 branches covered (92.65%)

Branch coverage included in aggregate %.

680 of 699 new or added lines in 104 files covered. (97.28%)

2 existing lines in 1 file now uncovered.

8700 of 8908 relevant lines covered (97.67%)

3506839.67 hits per line

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

92.31

/src/expressions/axes/AncestorAxis.ts

import { ChildNodePointer, ParentNodePointer } from '../../domClone/Pointer';
import DomFacade from '../../domFacade/DomFacade';
import createPointerValue from '../dataTypes/createPointerValue';
import sequenceFactory from '../dataTypes/sequenceFactory';
import Expression, { RESULT_ORDERINGS } from '../Expression';
import TestAbstractExpression from '../tests/TestAbstractExpression';
import { DONE_TOKEN, ready } from '../util/iterators';

function generateAncestors(
        domFacade: DomFacade,
        contextPointer: ChildNodePointer,
        bucket: string | null
) {
        let ancestor = contextPointer as ParentNodePointer;
        return {
                next: () => {
                        if (!ancestor) {
                                return DONE_TOKEN;
                        }

                        const previousAncestor = ancestor;
                        ancestor = domFacade.getParentNodePointer(previousAncestor as ChildNodePointer, bucket);

                        return ready(createPointerValue(previousAncestor, domFacade));
                },
        };
}

class AncestorAxis extends Expression {
        private _ancestorExpression: TestAbstractExpression;
        private _isInclusive: boolean;
        constructor(
                ancestorExpression: TestAbstractExpression,
                options: { inclusive: boolean } | undefined
        ) {
                options = options || { inclusive: false };
                super(ancestorExpression.specificity, [ancestorExpression], {
                        resultOrder: RESULT_ORDERINGS.REVERSE_SORTED,
                        peer: false,
                        subtree: false,
                        canBeStaticallyEvaluated: false,
                });

                this._ancestorExpression = ancestorExpression;
                this._isInclusive = !!options.inclusive;
        }

        public evaluate(dynamicContext, executionParameters) {
                const contextItem = dynamicContext.contextItem;
                if (contextItem === null) {
                        throw new Error('XPDY0002: context is absent, it needs to be present to use axes.');
                }

                const domFacade = executionParameters.domFacade;

                const contextPointer = contextItem.value;
                // Similar to the optimization for the Descendant axis, we know that only elements and
                // document nodes can contain other elements. Therefore, if we are looking for a specific
                // ancestor element, we only need to visit element ancestors. Because of this, we can pass
                // the 'type-1' bucket for each parent in that case.
                const ancestorExpressionBucket = this._ancestorExpression.getBucket();
                const onlyElementAncestors =
                        ancestorExpressionBucket &&
                        (ancestorExpressionBucket.startsWith('name-') || ancestorExpressionBucket === 'type-1');
                const ancestorAxisBucket = onlyElementAncestors ? 'type-1' : null;
                return sequenceFactory
                        .create(
                                generateAncestors(
                                        domFacade,
                                        this._isInclusive
                                                ? contextPointer
                                                : domFacade.getParentNodePointer(contextPointer, ancestorAxisBucket),
                                        ancestorAxisBucket
                                )
                        )
                        .filter((item) => {
                                return this._ancestorExpression.evaluateToBoolean(
                                        dynamicContext,
                                        item,
                                        executionParameters
                                );
                        });
        }
}

export default AncestorAxis;

1	import { ChildNodePointer, ParentNodePointer } from '../../domClone/Pointer';
2	import DomFacade from '../../domFacade/DomFacade';
3	import createPointerValue from '../dataTypes/createPointerValue';	15✔
4	import sequenceFactory from '../dataTypes/sequenceFactory';	15✔
5	import Expression, { RESULT_ORDERINGS } from '../Expression';	15✔
6	import TestAbstractExpression from '../tests/TestAbstractExpression';
7	import { DONE_TOKEN, ready } from '../util/iterators';	15✔
8
9	function generateAncestors(
10	domFacade: DomFacade,
11	contextPointer: ChildNodePointer,
12	bucket: string \| null
13	) {
14	let ancestor = contextPointer as ParentNodePointer;	1,182✔
15	return {	1,182✔
16	next: () => {
17	if (!ancestor) {	4,374✔
18	return DONE_TOKEN;	1,167✔
19	}
20
21	const previousAncestor = ancestor;	3,207✔
22	ancestor = domFacade.getParentNodePointer(previousAncestor as ChildNodePointer, bucket);	3,207✔
23
24	return ready(createPointerValue(previousAncestor, domFacade));	3,207✔
25	},
26	};
27	}
28
29	class AncestorAxis extends Expression {
30	private _ancestorExpression: TestAbstractExpression;
31	private _isInclusive: boolean;
32	constructor(
33	ancestorExpression: TestAbstractExpression,
34	options: { inclusive: boolean } \| undefined
35	) {
36	options = options \|\| { inclusive: false };	528!
37	super(ancestorExpression.specificity, [ancestorExpression], {	528✔
38	resultOrder: RESULT_ORDERINGS.REVERSE_SORTED,
39	peer: false,
40	subtree: false,
41	canBeStaticallyEvaluated: false,
42	});
43
44	this._ancestorExpression = ancestorExpression;	528✔
45	this._isInclusive = !!options.inclusive;	528✔
46	}
47
48	public evaluate(dynamicContext, executionParameters) {
49	const contextItem = dynamicContext.contextItem;	1,182✔
50	if (contextItem === null) {	1,182!
NEW 51	throw new Error('XPDY0002: context is absent, it needs to be present to use axes.');	×
52	}
53
54	const domFacade = executionParameters.domFacade;	1,182✔
55
56	const contextPointer = contextItem.value;	1,182✔
57	// Similar to the optimization for the Descendant axis, we know that only elements and
58	// document nodes can contain other elements. Therefore, if we are looking for a specific
59	// ancestor element, we only need to visit element ancestors. Because of this, we can pass
60	// the 'type-1' bucket for each parent in that case.
61	const ancestorExpressionBucket = this._ancestorExpression.getBucket();	1,182✔
62	const onlyElementAncestors =
63	ancestorExpressionBucket &&	1,182✔
64	(ancestorExpressionBucket.startsWith('name-') \|\| ancestorExpressionBucket === 'type-1');
65	const ancestorAxisBucket = onlyElementAncestors ? 'type-1' : null;	1,182✔
66	return sequenceFactory	1,182✔
67	.create(
68	generateAncestors(
69	domFacade,
70	this._isInclusive
71	? contextPointer	1,182✔
72	: domFacade.getParentNodePointer(contextPointer, ancestorAxisBucket),
73	ancestorAxisBucket
74	)
75	)
76	.filter((item) => {
77	return this._ancestorExpression.evaluateToBoolean(	3,207✔
78	dynamicContext,
79	item,
80	executionParameters
81	);
82	});
83	}
84	}
85
86	export default AncestorAxis;	15✔

FontoXML / fontoxpath / 893119273

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