1422978406

Build Type

github

Committed by GitHub

Commit Message

Merge c8f1d26f1 into 74c3958c7

Pull Request Pull Request #437: Implementation of distinct-values

Run Details

4703 of 5066 branches covered (92.83%)

Branch coverage included in aggregate %.

11 of 11 new or added lines in 2 files covered. (100.0%)

3 existing lines in 1 file now uncovered.

9453 of 9692 relevant lines covered (97.53%)

6772582.49 hits per line

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

96.5

/src/expressions/functions/builtInFunctions_sequences_deepEqual.ts

import { NodePointer, TextNodePointer } from '../../domClone/Pointer';
import { NODE_TYPES } from '../../domFacade/ConcreteNode';
import DomFacade from '../../domFacade/DomFacade';
import ArrayValue from '../dataTypes/ArrayValue';
import { atomizeSingleValue } from '../dataTypes/atomize';
import castToType from '../dataTypes/castToType';
import createPointerValue from '../dataTypes/createPointerValue';
import ISequence from '../dataTypes/ISequence';
import isSubtypeOf from '../dataTypes/isSubtypeOf';
import MapValue from '../dataTypes/MapValue';
import sequenceFactory from '../dataTypes/sequenceFactory';
import Value, { ValueType } from '../dataTypes/Value';
import { equal } from '../dataTypes/valueTypes/DateTime';
import DynamicContext from '../DynamicContext';
import ExecutionParameters from '../ExecutionParameters';
import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
import StaticContext from '../StaticContext';
import createSingleValueIterator from '../util/createSingleValueIterator';
import { DONE_TOKEN, IIterator, IterationHint, IterationResult, ready } from '../util/iterators';
import builtInFunctionsNode from './builtInFunctions_node';

const nodeName = builtInFunctionsNode.functions.nodeName;

function asyncGenerateEvery<T>(
        items: T[],
        callback: (item: T, index: number, all: T[]) => IIterator<boolean>
): IIterator<boolean> {
        let i = 0;
        const l = items.length;
        let done = false;
        let filterGenerator: IIterator<boolean> = null;
        return {
                next: () => {
                        if (!done) {
                                while (i < l) {
                                        if (!filterGenerator) {
                                                filterGenerator = callback(items[i], i, items);
                                        }
                                        const filterResult = filterGenerator.next(IterationHint.NONE);
                                        filterGenerator = null;
                                        if (filterResult.value) {
                                                i++;
                                                continue;
                                        }
                                        return ready(false);
                                }
                                done = true;
                                return ready(true);
                        }
                        return DONE_TOKEN;
                },
        };
}

function filterElementAndTextNodes(node: NodePointer, domFacade: DomFacade) {
        const nodeType = domFacade.getNodeType(node);
        return nodeType === NODE_TYPES.ELEMENT_NODE || nodeType === NODE_TYPES.TEXT_NODE;
}

export function anyAtomicTypeDeepEqual(
        _dynamicContext: DynamicContext,
        _executionParameters: ExecutionParameters,
        _staticContext: StaticContext,
        item1: Value,
        item2: Value
): boolean {
        if (
                (isSubtypeOf(item1.type, ValueType.XSDECIMAL) ||
                        isSubtypeOf(item1.type, ValueType.XSFLOAT)) &&
                (isSubtypeOf(item2.type, ValueType.XSDECIMAL) || isSubtypeOf(item2.type, ValueType.XSFLOAT))
        ) {
                const temp1 = castToType(item1, ValueType.XSFLOAT);
                const temp2 = castToType(item2, ValueType.XSFLOAT);
                return temp1.value === temp2.value || (isNaN(item1.value) && isNaN(item2.value));
        }
        if (
                (isSubtypeOf(item1.type, ValueType.XSDECIMAL) ||
                        isSubtypeOf(item1.type, ValueType.XSFLOAT) ||
                        isSubtypeOf(item1.type, ValueType.XSDOUBLE)) &&
                (isSubtypeOf(item2.type, ValueType.XSDECIMAL) ||
                        isSubtypeOf(item2.type, ValueType.XSFLOAT) ||
                        isSubtypeOf(item2.type, ValueType.XSDOUBLE))
        ) {
                const temp1 = castToType(item1, ValueType.XSDOUBLE);
                const temp2 = castToType(item2, ValueType.XSDOUBLE);
                return temp1.value === temp2.value || (isNaN(item1.value) && isNaN(item2.value));
        }

        if (isSubtypeOf(item1.type, ValueType.XSQNAME) && isSubtypeOf(item2.type, ValueType.XSQNAME)) {
                return (
                        item1.value.namespaceURI === item2.value.namespaceURI &&
                        item1.value.localName === item2.value.localName
                );
        }

        if (
                (isSubtypeOf(item1.type, ValueType.XSDATETIME) ||
                        isSubtypeOf(item1.type, ValueType.XSDATE) ||
                        isSubtypeOf(item1.type, ValueType.XSTIME) ||
                        isSubtypeOf(item1.type, ValueType.XSGYEARMONTH) ||
                        isSubtypeOf(item1.type, ValueType.XSGYEAR) ||
                        isSubtypeOf(item1.type, ValueType.XSGMONTHDAY) ||
                        isSubtypeOf(item1.type, ValueType.XSGMONTH) ||
                        isSubtypeOf(item1.type, ValueType.XSGDAY)) &&
                (isSubtypeOf(item2.type, ValueType.XSDATETIME) ||
                        isSubtypeOf(item2.type, ValueType.XSDATE) ||
                        isSubtypeOf(item2.type, ValueType.XSTIME) ||
                        isSubtypeOf(item2.type, ValueType.XSGYEARMONTH) ||
                        isSubtypeOf(item2.type, ValueType.XSGYEAR) ||
                        isSubtypeOf(item2.type, ValueType.XSGMONTHDAY) ||
                        isSubtypeOf(item2.type, ValueType.XSGMONTH) ||
                        isSubtypeOf(item2.type, ValueType.XSGDAY))
        ) {
                return equal(item1.value, item2.value);
        }
        return item1.value === item2.value;
}

function compareNormalizedTextNodes(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        textValues1: Value[],
        textValues2: Value[]
) {
        const [atomicValue1, atomicValue2]: Value[] = [textValues1, textValues2].map((textValues) => {
                const value = textValues.reduce((wholeValue, textValue) => {
                        wholeValue =
                                wholeValue + atomizeSingleValue(textValue, executionParameters).first().value;

                        return wholeValue;
                }, '');

                return {
                        type: ValueType.XSSTRING,
                        value,
                };
        });

        return ready(
                anyAtomicTypeDeepEqual(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        atomicValue1,
                        atomicValue2
                )
        );
}

function takeConsecutiveTextValues(
        item: IterationResult<Value>,
        textValues: Value[],
        iterator: IIterator<Value>,
        domFacade: DomFacade
): IterationResult<Value> {
        while (item.value && isSubtypeOf(item.value.type, ValueType.TEXT)) {
                textValues.push(item.value);
                const nextSibling = domFacade.getNextSiblingPointer(item.value.value as TextNodePointer);
                item = iterator.next(IterationHint.NONE);
                if (nextSibling && domFacade.getNodeType(nextSibling) !== NODE_TYPES.TEXT_NODE) {
                        break;
                }
        }
        return item;
}

function sequenceDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        sequence1: ISequence,
        sequence2: ISequence
): IIterator<boolean> {
        const domFacade = executionParameters.domFacade;
        const it1 = sequence1.value;
        const it2 = sequence2.value;
        let item1: IterationResult<Value> = null;
        let item2: IterationResult<Value> = null;
        let comparisonGenerator: IIterator<boolean> = null;
        let done: boolean;
        const textValues1: Value[] = [];
        const textValues2: Value[] = [];
        return {
                next: (_hint: IterationHint) => {
                        while (!done) {
                                if (!item1) {
                                        item1 = it1.next(IterationHint.NONE);
                                }
                                item1 = takeConsecutiveTextValues(item1, textValues1, it1, domFacade);

                                if (!item2) {
                                        item2 = it2.next(IterationHint.NONE);
                                }
                                item2 = takeConsecutiveTextValues(item2, textValues2, it2, domFacade);

                                if (textValues1.length || textValues2.length) {
                                        const textComparisonResult = compareNormalizedTextNodes(
                                                dynamicContext,
                                                executionParameters,
                                                staticContext,
                                                textValues1,
                                                textValues2
                                        );
                                        textValues1.length = 0;
                                        textValues2.length = 0;
                                        if (textComparisonResult.value === false) {
                                                done = true;
                                                return textComparisonResult;
                                        }

                                        // We compare the textNodes so far, we should continue as normal.
                                        continue;
                                }

                                if (item1.done || item2.done) {
                                        done = true;
                                        return ready(item1.done === item2.done);
                                }

                                if (!comparisonGenerator) {
                                        comparisonGenerator = itemDeepEqual(
                                                dynamicContext,
                                                executionParameters,
                                                staticContext,
                                                item1.value,
                                                item2.value
                                        );
                                }
                                const comparisonResult = comparisonGenerator.next(IterationHint.NONE);
                                comparisonGenerator = null;
                                if (comparisonResult.value === false) {
                                        done = true;
                                        return comparisonResult;
                                }

                                // Compare next one
                                item1 = null;
                                item2 = null;
                        }
                        return DONE_TOKEN;
                },
        };
}

function mapTypeDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        item1: MapValue,
        item2: MapValue
): IIterator<boolean> {
        if (item1.keyValuePairs.length !== item2.keyValuePairs.length) {
                return createSingleValueIterator(false);
        }

        return asyncGenerateEvery(item1.keyValuePairs, (mapEntry1) => {
                const mapEntry2 = item2.keyValuePairs.find((entry) =>
                        anyAtomicTypeDeepEqual(
                                dynamicContext,
                                executionParameters,
                                staticContext,
                                entry.key,
                                mapEntry1.key
                        )
                );

                if (!mapEntry2) {
                        return createSingleValueIterator(false);
                }

                return sequenceDeepEqual(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        mapEntry1.value(),
                        mapEntry2.value()
                );
        });
}

function arrayTypeDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        item1: ArrayValue,
        item2: ArrayValue
): IIterator<boolean> {
        if (item1.members.length !== item2.members.length) {
                return createSingleValueIterator(false);
        }

        return asyncGenerateEvery<() => ISequence>(item1.members, (arrayEntry1, index) => {
                const arrayEntry2 = item2.members[index];
                return sequenceDeepEqual(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        arrayEntry1(),
                        arrayEntry2()
                );
        });
}

function nodeDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        item1: Value,
        item2: Value
): IIterator<boolean> {
        let item1Nodes = executionParameters.domFacade.getChildNodePointers(item1.value);
        let item2Nodes = executionParameters.domFacade.getChildNodePointers(item2.value);

        item1Nodes = item1Nodes.filter((item1Node) =>
                filterElementAndTextNodes(item1Node, executionParameters.domFacade)
        );
        item2Nodes = item2Nodes.filter((item2Node) =>
                filterElementAndTextNodes(item2Node, executionParameters.domFacade)
        );

        const item1NodesSeq = sequenceFactory.create(
                item1Nodes.map((node) => createPointerValue(node, executionParameters.domFacade))
        );
        const item2NodesSeq = sequenceFactory.create(
                item2Nodes.map((node) => createPointerValue(node, executionParameters.domFacade))
        );

        return sequenceDeepEqual(
                dynamicContext,
                executionParameters,
                staticContext,
                item1NodesSeq,
                item2NodesSeq
        );
}

function elementNodeDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        item1: Value,
        item2: Value
): IIterator<boolean> {
        const namesAreEqualResultGenerator = sequenceDeepEqual(
                dynamicContext,
                executionParameters,
                staticContext,
                nodeName(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        sequenceFactory.singleton(item1)
                ),
                nodeName(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        sequenceFactory.singleton(item2)
                )
        );
        const nodeDeepEqualGenerator = nodeDeepEqual(
                dynamicContext,
                executionParameters,
                staticContext,
                item1,
                item2
        );
        const domFacade = executionParameters.domFacade;
        const attributes1 = domFacade
                .getAllAttributePointers(item1.value)
                .filter(
                        (attr) =>
                                domFacade.getNamespaceURI(attr) !== BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI
                )
                .sort((attrA, attrB) =>
                        domFacade.getNodeName(attrA) > domFacade.getNodeName(attrB) ? 1 : -1
                )
                .map((attr) => createPointerValue(attr, executionParameters.domFacade));

        const attributes2 = executionParameters.domFacade
                .getAllAttributePointers(item2.value)
                .filter(
                        (attr) =>
                                domFacade.getNamespaceURI(attr) !== BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI
                )
                .sort((attrA, attrB) =>
                        domFacade.getNodeName(attrA) > domFacade.getNodeName(attrB) ? 1 : -1
                )
                .map((attr) => createPointerValue(attr, executionParameters.domFacade));

        const attributesDeepEqualGenerator = sequenceDeepEqual(
                dynamicContext,
                executionParameters,
                staticContext,
                sequenceFactory.create(attributes1),
                sequenceFactory.create(attributes2)
        );
        let done = false;
        return {
                next: (_hint: IterationHint) => {
                        if (done) {
                                return DONE_TOKEN;
                        }
                        const namesAreEqualResult = namesAreEqualResultGenerator.next(IterationHint.NONE);
                        if (!namesAreEqualResult.done && namesAreEqualResult.value === false) {
                                done = true;
                                return namesAreEqualResult;
                        }

                        const attributesEqualResult = attributesDeepEqualGenerator.next(IterationHint.NONE);
                        if (!attributesEqualResult.done && attributesEqualResult.value === false) {
                                done = true;
                                return attributesEqualResult;
                        }

                        const contentsEqualResult = nodeDeepEqualGenerator.next(IterationHint.NONE);
                        done = true;
                        return contentsEqualResult;
                },
        };
}

function atomicTypeNodeDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        item1: Value,
        item2: Value
): IIterator<boolean> {
        const namesAreEqualResultGenerator = sequenceDeepEqual(
                dynamicContext,
                executionParameters,
                staticContext,
                nodeName(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        sequenceFactory.singleton(item1)
                ),
                nodeName(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        sequenceFactory.singleton(item2)
                )
        );
        let done = false;
        return {
                next: (_hint: IterationHint) => {
                        if (done) {
                                return DONE_TOKEN;
                        }
                        const namesAreEqualResult = namesAreEqualResultGenerator.next(IterationHint.NONE);
                        if (!namesAreEqualResult.done) {
                                if (namesAreEqualResult.value === false) {
                                        done = true;
                                        return namesAreEqualResult;
                                }
                        }
                        // Assume here that a node always atomizes to a singlevalue. This will not work
                        // anymore when schema support will be imlemented.

                        return ready(
                                anyAtomicTypeDeepEqual(
                                        dynamicContext,
                                        executionParameters,
                                        staticContext,
                                        atomizeSingleValue(item1, executionParameters).first(),
                                        atomizeSingleValue(item2, executionParameters).first()
                                )
                        );
                },
        };
}

export function itemDeepEqual(
        dynamicContext: DynamicContext,
        executionParameters: ExecutionParameters,
        staticContext: StaticContext,
        item1: Value,
        item2: Value
): IIterator<boolean> {
        // All atomic types
        if (
                isSubtypeOf(item1.type, ValueType.XSANYATOMICTYPE) &&
                isSubtypeOf(item2.type, ValueType.XSANYATOMICTYPE)
        ) {
                return createSingleValueIterator(
                        anyAtomicTypeDeepEqual(dynamicContext, executionParameters, staticContext, item1, item2)
                );
        }

        // Maps
        if (isSubtypeOf(item1.type, ValueType.MAP) && isSubtypeOf(item2.type, ValueType.MAP)) {
                return mapTypeDeepEqual(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        item1 as MapValue,
                        item2 as MapValue
                );
        }

        // Arrays
        if (isSubtypeOf(item1.type, ValueType.ARRAY) && isSubtypeOf(item2.type, ValueType.ARRAY)) {
                return arrayTypeDeepEqual(
                        dynamicContext,
                        executionParameters,
                        staticContext,
                        item1 as ArrayValue,
                        item2 as ArrayValue
                );
        }

        // Nodes
        if (isSubtypeOf(item1.type, ValueType.NODE) && isSubtypeOf(item2.type, ValueType.NODE)) {
                // Document nodes
                if (
                        isSubtypeOf(item1.type, ValueType.DOCUMENTNODE) &&
                        isSubtypeOf(item2.type, ValueType.DOCUMENTNODE)
                ) {
                        return nodeDeepEqual(dynamicContext, executionParameters, staticContext, item1, item2);
                }

                // Element nodes, cannot be compared due to missing schema information
                if (
                        isSubtypeOf(item1.type, ValueType.ELEMENT) &&
                        isSubtypeOf(item2.type, ValueType.ELEMENT)
                ) {
                        return elementNodeDeepEqual(
                                dynamicContext,
                                executionParameters,
                                staticContext,
                                item1,
                                item2
                        );
                }

                // Attribute nodes
                if (
                        isSubtypeOf(item1.type, ValueType.ATTRIBUTE) &&
                        isSubtypeOf(item2.type, ValueType.ATTRIBUTE)
                ) {
                        return atomicTypeNodeDeepEqual(
                                dynamicContext,
                                executionParameters,
                                staticContext,
                                item1,
                                item2
                        );
                }

                // Processing instruction node
                if (
                        isSubtypeOf(item1.type, ValueType.PROCESSINGINSTRUCTION) &&
                        isSubtypeOf(item2.type, ValueType.PROCESSINGINSTRUCTION)
                ) {
                        return atomicTypeNodeDeepEqual(
                                dynamicContext,
                                executionParameters,
                                staticContext,
                                item1,
                                item2
                        );
                }

                // Comment nodes
                if (
                        isSubtypeOf(item1.type, ValueType.COMMENT) &&
                        isSubtypeOf(item2.type, ValueType.COMMENT)
                ) {
                        return atomicTypeNodeDeepEqual(
                                dynamicContext,
                                executionParameters,
                                staticContext,
                                item1,
                                item2
                        );
                }

                // TextNodes
        }

        return createSingleValueIterator(false);
}

export default sequenceDeepEqual;

1	import { NodePointer, TextNodePointer } from '../../domClone/Pointer';
2	import { NODE_TYPES } from '../../domFacade/ConcreteNode';
3	import DomFacade from '../../domFacade/DomFacade';
4	import ArrayValue from '../dataTypes/ArrayValue';
5	import { atomizeSingleValue } from '../dataTypes/atomize';	18✔
6	import castToType from '../dataTypes/castToType';	18✔
7	import createPointerValue from '../dataTypes/createPointerValue';	18✔
8	import ISequence from '../dataTypes/ISequence';
9	import isSubtypeOf from '../dataTypes/isSubtypeOf';	18✔
10	import MapValue from '../dataTypes/MapValue';
11	import sequenceFactory from '../dataTypes/sequenceFactory';	18✔
12	import Value, { ValueType } from '../dataTypes/Value';
13	import { equal } from '../dataTypes/valueTypes/DateTime';	18✔
14	import DynamicContext from '../DynamicContext';
15	import ExecutionParameters from '../ExecutionParameters';
16	import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
17	import StaticContext from '../StaticContext';
18	import createSingleValueIterator from '../util/createSingleValueIterator';	18✔
19	import { DONE_TOKEN, IIterator, IterationHint, IterationResult, ready } from '../util/iterators';	18✔
20	import builtInFunctionsNode from './builtInFunctions_node';	18✔
21
22	const nodeName = builtInFunctionsNode.functions.nodeName;	18✔
23
24	function asyncGenerateEvery<T>(
25	items: T[],
26	callback: (item: T, index: number, all: T[]) => IIterator<boolean>
27	): IIterator<boolean> {
28	let i = 0;	8,214✔
29	const l = items.length;	8,214✔
30	let done = false;	8,214✔
31	let filterGenerator: IIterator<boolean> = null;	8,214✔
32	return {	8,214✔
33	next: () => {
34	if (!done) {	8,214!
35	while (i < l) {	8,214✔
36	if (!filterGenerator) {	31,863!
37	filterGenerator = callback(items[i], i, items);	31,863✔
38	}
39	const filterResult = filterGenerator.next(IterationHint.NONE);	31,863✔
40	filterGenerator = null;	31,863✔
41	if (filterResult.value) {	31,863✔
42	i++;	31,812✔
43	continue;	31,812✔
44	}
45	return ready(false);	51✔
46	}
47	done = true;	8,163✔
48	return ready(true);	8,163✔
49	}
50	return DONE_TOKEN;	×
51	},
52	};
53	}
54
55	function filterElementAndTextNodes(node: NodePointer, domFacade: DomFacade) {
56	const nodeType = domFacade.getNodeType(node);	866,442✔
57	return nodeType === NODE_TYPES.ELEMENT_NODE \|\| nodeType === NODE_TYPES.TEXT_NODE;	866,442✔
58	}
59
60	export function anyAtomicTypeDeepEqual(	18✔
61	_dynamicContext: DynamicContext,
62	_executionParameters: ExecutionParameters,
63	_staticContext: StaticContext,
64	item1: Value,
65	item2: Value
66	): boolean {
67	if (	4,305,489✔
68	(isSubtypeOf(item1.type, ValueType.XSDECIMAL) \|\|	8,611,605✔
69	isSubtypeOf(item1.type, ValueType.XSFLOAT)) &&
70	(isSubtypeOf(item2.type, ValueType.XSDECIMAL) \|\| isSubtypeOf(item2.type, ValueType.XSFLOAT))
71	) {
72	const temp1 = castToType(item1, ValueType.XSFLOAT);	3,533,013✔
73	const temp2 = castToType(item2, ValueType.XSFLOAT);	3,533,013✔
74	return temp1.value === temp2.value \|\| (isNaN(item1.value) && isNaN(item2.value));	3,533,013✔
75	}
76	if (	772,476✔
77	(isSubtypeOf(item1.type, ValueType.XSDECIMAL) \|\|	2,320,653✔
78	isSubtypeOf(item1.type, ValueType.XSFLOAT) \|\|
79	isSubtypeOf(item1.type, ValueType.XSDOUBLE)) &&
80	(isSubtypeOf(item2.type, ValueType.XSDECIMAL) \|\|
81	isSubtypeOf(item2.type, ValueType.XSFLOAT) \|\|
82	isSubtypeOf(item2.type, ValueType.XSDOUBLE))
83	) {
84	const temp1 = castToType(item1, ValueType.XSDOUBLE);	1,194✔
85	const temp2 = castToType(item2, ValueType.XSDOUBLE);	1,194✔
86	return temp1.value === temp2.value \|\| (isNaN(item1.value) && isNaN(item2.value));	1,194✔
87	}
88
89	if (isSubtypeOf(item1.type, ValueType.XSQNAME) && isSubtypeOf(item2.type, ValueType.XSQNAME)) {	771,282✔
90	return (	337,728✔
91	item1.value.namespaceURI === item2.value.namespaceURI &&	675,456✔
92	item1.value.localName === item2.value.localName
93	);
94	}
95
96	if (	433,554✔
97	(isSubtypeOf(item1.type, ValueType.XSDATETIME) \|\|	3,467,352✔
98	isSubtypeOf(item1.type, ValueType.XSDATE) \|\|
99	isSubtypeOf(item1.type, ValueType.XSTIME) \|\|
100	isSubtypeOf(item1.type, ValueType.XSGYEARMONTH) \|\|
101	isSubtypeOf(item1.type, ValueType.XSGYEAR) \|\|
102	isSubtypeOf(item1.type, ValueType.XSGMONTHDAY) \|\|
103	isSubtypeOf(item1.type, ValueType.XSGMONTH) \|\|
104	isSubtypeOf(item1.type, ValueType.XSGDAY)) &&
105	(isSubtypeOf(item2.type, ValueType.XSDATETIME) \|\|
106	isSubtypeOf(item2.type, ValueType.XSDATE) \|\|
107	isSubtypeOf(item2.type, ValueType.XSTIME) \|\|
108	isSubtypeOf(item2.type, ValueType.XSGYEARMONTH) \|\|
109	isSubtypeOf(item2.type, ValueType.XSGYEAR) \|\|
110	isSubtypeOf(item2.type, ValueType.XSGMONTHDAY) \|\|
111	isSubtypeOf(item2.type, ValueType.XSGMONTH) \|\|
112	isSubtypeOf(item2.type, ValueType.XSGDAY))
113	) {
114	return equal(item1.value, item2.value);	372✔
115	}
116	return item1.value === item2.value;	433,182✔
117	}
118
119	function compareNormalizedTextNodes(
120	dynamicContext: DynamicContext,
121	executionParameters: ExecutionParameters,
122	staticContext: StaticContext,
123	textValues1: Value[],
124	textValues2: Value[]
125	) {
126	const [atomicValue1, atomicValue2]: Value[] = [textValues1, textValues2].map((textValues) => {	153,042✔
127	const value = textValues.reduce((wholeValue, textValue) => {	306,084✔
128	wholeValue =	306,252✔
129	wholeValue + atomizeSingleValue(textValue, executionParameters).first().value;
130
131	return wholeValue;	306,252✔
132	}, '');
133
134	return {	306,084✔
135	type: ValueType.XSSTRING,
136	value,
137	};
138	});
139
140	return ready(	153,042✔
141	anyAtomicTypeDeepEqual(
142	dynamicContext,
143	executionParameters,
144	staticContext,
145	atomicValue1,
146	atomicValue2
147	)
148	);
149	}
150
151	function takeConsecutiveTextValues(
152	item: IterationResult<Value>,
153	textValues: Value[],
154	iterator: IIterator<Value>,
155	domFacade: DomFacade
156	): IterationResult<Value> {
157	while (item.value && isSubtypeOf(item.value.type, ValueType.TEXT)) {	3,697,374✔
158	textValues.push(item.value);	306,252✔
159	const nextSibling = domFacade.getNextSiblingPointer(item.value.value as TextNodePointer);	306,252✔
160	item = iterator.next(IterationHint.NONE);	306,252✔
161	if (nextSibling && domFacade.getNodeType(nextSibling) !== NODE_TYPES.TEXT_NODE) {	306,252✔
162	break;	31,746✔
163	}
164	}
165	return item;	3,697,374✔
166	}
167
168	function sequenceDeepEqual(
169	dynamicContext: DynamicContext,
170	executionParameters: ExecutionParameters,
171	staticContext: StaticContext,
172	sequence1: ISequence,
173	sequence2: ISequence
174	): IIterator<boolean> {
175	const domFacade = executionParameters.domFacade;	983,310✔
176	const it1 = sequence1.value;	983,310✔
177	const it2 = sequence2.value;	983,310✔
178	let item1: IterationResult<Value> = null;	983,310✔
179	let item2: IterationResult<Value> = null;	983,310✔
180	let comparisonGenerator: IIterator<boolean> = null;	983,310✔
181	let done: boolean;
182	const textValues1: Value[] = [];	983,310✔
183	const textValues2: Value[] = [];	983,310✔
184	return {	983,310✔
185	next: (_hint: IterationHint) => {
186	while (!done) {	982,782✔
187	if (!item1) {	1,848,687✔
188	item1 = it1.next(IterationHint.NONE);	1,695,891✔
189	}
190	item1 = takeConsecutiveTextValues(item1, textValues1, it1, domFacade);	1,848,687✔
191
192	if (!item2) {	1,848,687✔
193	item2 = it2.next(IterationHint.NONE);	1,695,891✔
194	}
195	item2 = takeConsecutiveTextValues(item2, textValues2, it2, domFacade);	1,848,687✔
196
197	if (textValues1.length \|\| textValues2.length) {	1,848,687✔
198	const textComparisonResult = compareNormalizedTextNodes(	153,042✔
199	dynamicContext,
200	executionParameters,
201	staticContext,
202	textValues1,
203	textValues2
204	);
205	textValues1.length = 0;	153,042✔
206	textValues2.length = 0;	153,042✔
207	if (textComparisonResult.value === false) {	153,042✔
208	done = true;	246✔
209	return textComparisonResult;	246✔
210	}
211
212	// We compare the textNodes so far, we should continue as normal.
213	continue;	152,796✔
214	}
215
216	if (item1.done \|\| item2.done) {	1,695,645✔
217	done = true;	980,697✔
218	return ready(item1.done === item2.done);	980,697✔
219	}
220
221	if (!comparisonGenerator) {	714,948!
222	comparisonGenerator = itemDeepEqual(	714,948✔
223	dynamicContext,
224	executionParameters,
225	staticContext,
226	item1.value,
227	item2.value
228	);
229	}
230	const comparisonResult = comparisonGenerator.next(IterationHint.NONE);	714,948✔
231	comparisonGenerator = null;	714,948✔
232	if (comparisonResult.value === false) {	714,948✔
233	done = true;	1,839✔
234	return comparisonResult;	1,839✔
235	}
236
237	// Compare next one
238	item1 = null;	713,109✔
239	item2 = null;	713,109✔
240	}
UNCOV 241	return DONE_TOKEN;	×
242	},
243	};
244	}
245
246	function mapTypeDeepEqual(
247	dynamicContext: DynamicContext,
248	executionParameters: ExecutionParameters,
249	staticContext: StaticContext,
250	item1: MapValue,
251	item2: MapValue
252	): IIterator<boolean> {
253	if (item1.keyValuePairs.length !== item2.keyValuePairs.length) {	741✔
254	return createSingleValueIterator(false);	33✔
255	}
256
257	return asyncGenerateEvery(item1.keyValuePairs, (mapEntry1) => {	708✔
258	const mapEntry2 = item2.keyValuePairs.find((entry) =>	10,014✔
259	anyAtomicTypeDeepEqual(	3,499,977✔
260	dynamicContext,
261	executionParameters,
262	staticContext,
263	entry.key,
264	mapEntry1.key
265	)
266	);
267
268	if (!mapEntry2) {	10,014✔
269	return createSingleValueIterator(false);	9✔
270	}
271
272	return sequenceDeepEqual(	10,005✔
273	dynamicContext,
274	executionParameters,
275	staticContext,
276	mapEntry1.value(),
277	mapEntry2.value()
278	);
279	});
280	}
281
282	function arrayTypeDeepEqual(
283	dynamicContext: DynamicContext,
284	executionParameters: ExecutionParameters,
285	staticContext: StaticContext,
286	item1: ArrayValue,
287	item2: ArrayValue
288	): IIterator<boolean> {
289	if (item1.members.length !== item2.members.length) {	7,521✔
290	return createSingleValueIterator(false);	15✔
291	}
292
293	return asyncGenerateEvery<() => ISequence>(item1.members, (arrayEntry1, index) => {	7,506✔
294	const arrayEntry2 = item2.members[index];	21,849✔
295	return sequenceDeepEqual(	21,849✔
296	dynamicContext,
297	executionParameters,
298	staticContext,
299	arrayEntry1(),
300	arrayEntry2()
301	);
302	});
303	}
304
305	function nodeDeepEqual(
306	dynamicContext: DynamicContext,
307	executionParameters: ExecutionParameters,
308	staticContext: StaticContext,
309	item1: Value,
310	item2: Value
311	): IIterator<boolean> {
312	let item1Nodes = executionParameters.domFacade.getChildNodePointers(item1.value);	299,226✔
313	let item2Nodes = executionParameters.domFacade.getChildNodePointers(item2.value);	299,226✔
314
315	item1Nodes = item1Nodes.filter((item1Node) =>	299,226✔
316	filterElementAndTextNodes(item1Node, executionParameters.domFacade)	433,194✔
317	);
318	item2Nodes = item2Nodes.filter((item2Node) =>	299,226✔
319	filterElementAndTextNodes(item2Node, executionParameters.domFacade)	433,248✔
320	);
321
322	const item1NodesSeq = sequenceFactory.create(	299,226✔
323	item1Nodes.map((node) => createPointerValue(node, executionParameters.domFacade))	430,611✔
324	);
325	const item2NodesSeq = sequenceFactory.create(	299,226✔
326	item2Nodes.map((node) => createPointerValue(node, executionParameters.domFacade))	430,716✔
327	);
328
329	return sequenceDeepEqual(	299,226✔
330	dynamicContext,
331	executionParameters,
332	staticContext,
333	item1NodesSeq,
334	item2NodesSeq
335	);
336	}
337
338	function elementNodeDeepEqual(
339	dynamicContext: DynamicContext,
340	executionParameters: ExecutionParameters,
341	staticContext: StaticContext,
342	item1: Value,
343	item2: Value
344	): IIterator<boolean> {
345	const namesAreEqualResultGenerator = sequenceDeepEqual(	296,919✔
346	dynamicContext,
347	executionParameters,
348	staticContext,
349	nodeName(
350	dynamicContext,
351	executionParameters,
352	staticContext,
353	sequenceFactory.singleton(item1)
354	),
355	nodeName(
356	dynamicContext,
357	executionParameters,
358	staticContext,
359	sequenceFactory.singleton(item2)
360	)
361	);
362	const nodeDeepEqualGenerator = nodeDeepEqual(	296,919✔
363	dynamicContext,
364	executionParameters,
365	staticContext,
366	item1,
367	item2
368	);
369	const domFacade = executionParameters.domFacade;	296,919✔
370	const attributes1 = domFacade	296,919✔
371	.getAllAttributePointers(item1.value)
372	.filter(
373	(attr) =>
374	domFacade.getNamespaceURI(attr) !== BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI	46,998✔
375	)
376	.sort((attrA, attrB) =>
377	domFacade.getNodeName(attrA) > domFacade.getNodeName(attrB) ? 1 : -1	4,515✔
378	)
379	.map((attr) => createPointerValue(attr, executionParameters.domFacade));	40,164✔
380
381	const attributes2 = executionParameters.domFacade	296,919✔
382	.getAllAttributePointers(item2.value)
383	.filter(
384	(attr) =>
385	domFacade.getNamespaceURI(attr) !== BUILT_IN_NAMESPACE_URIS.XMLNS_NAMESPACE_URI	42,258✔
386	)
387	.sort((attrA, attrB) =>
388	domFacade.getNodeName(attrA) > domFacade.getNodeName(attrB) ? 1 : -1	4,926✔
389	)
390	.map((attr) => createPointerValue(attr, executionParameters.domFacade));	40,161✔
391
392	const attributesDeepEqualGenerator = sequenceDeepEqual(	296,919✔
393	dynamicContext,
394	executionParameters,
395	staticContext,
396	sequenceFactory.create(attributes1),
397	sequenceFactory.create(attributes2)
398	);
399	let done = false;	296,919✔
400	return {	296,919✔
401	next: (_hint: IterationHint) => {
402	if (done) {	296,919!
UNCOV 403	return DONE_TOKEN;	×
404	}
405	const namesAreEqualResult = namesAreEqualResultGenerator.next(IterationHint.NONE);	296,919✔
406	if (!namesAreEqualResult.done && namesAreEqualResult.value === false) {	296,919✔
407	done = true;	237✔
408	return namesAreEqualResult;	237✔
409	}
410
411	const attributesEqualResult = attributesDeepEqualGenerator.next(IterationHint.NONE);	296,682✔
412	if (!attributesEqualResult.done && attributesEqualResult.value === false) {	296,682✔
413	done = true;	54✔
414	return attributesEqualResult;	54✔
415	}
416
417	const contentsEqualResult = nodeDeepEqualGenerator.next(IterationHint.NONE);	296,628✔
418	done = true;	296,628✔
419	return contentsEqualResult;	296,628✔
420	},
421	};
422	}
423
424	function atomicTypeNodeDeepEqual(
425	dynamicContext: DynamicContext,
426	executionParameters: ExecutionParameters,
427	staticContext: StaticContext,
428	item1: Value,
429	item2: Value
430	): IIterator<boolean> {
431	const namesAreEqualResultGenerator = sequenceDeepEqual(	41,256✔
432	dynamicContext,
433	executionParameters,
434	staticContext,
435	nodeName(
436	dynamicContext,
437	executionParameters,
438	staticContext,
439	sequenceFactory.singleton(item1)
440	),
441	nodeName(
442	dynamicContext,
443	executionParameters,
444	staticContext,
445	sequenceFactory.singleton(item2)
446	)
447	);
448	let done = false;	41,256✔
449	return {	41,256✔
450	next: (_hint: IterationHint) => {
451	if (done) {	41,256!
UNCOV 452	return DONE_TOKEN;	×
453	}
454	const namesAreEqualResult = namesAreEqualResultGenerator.next(IterationHint.NONE);	41,256✔
455	if (!namesAreEqualResult.done) {	41,256!
456	if (namesAreEqualResult.value === false) {	41,256✔
457	done = true;	33✔
458	return namesAreEqualResult;	33✔
459	}
460	}
461	// Assume here that a node always atomizes to a singlevalue. This will not work
462	// anymore when schema support will be imlemented.
463
464	return ready(	41,223✔
465	anyAtomicTypeDeepEqual(
466	dynamicContext,
467	executionParameters,
468	staticContext,
469	atomizeSingleValue(item1, executionParameters).first(),
470	atomizeSingleValue(item2, executionParameters).first()
471	)
472	);
473	},
474	};
475	}
476
477	export function itemDeepEqual(	18✔
478	dynamicContext: DynamicContext,
479	executionParameters: ExecutionParameters,
480	staticContext: StaticContext,
481	item1: Value,
482	item2: Value
483	): IIterator<boolean> {
484	// All atomic types
485	if (	715,140✔
486	isSubtypeOf(item1.type, ValueType.XSANYATOMICTYPE) &&	1,081,509✔
487	isSubtypeOf(item2.type, ValueType.XSANYATOMICTYPE)
488	) {
489	return createSingleValueIterator(	366,351✔
490	anyAtomicTypeDeepEqual(dynamicContext, executionParameters, staticContext, item1, item2)
491	);
492	}
493
494	// Maps
495	if (isSubtypeOf(item1.type, ValueType.MAP) && isSubtypeOf(item2.type, ValueType.MAP)) {	348,789✔
496	return mapTypeDeepEqual(	741✔
497	dynamicContext,
498	executionParameters,
499	staticContext,
500	item1 as MapValue,
501	item2 as MapValue
502	);
503	}
504
505	// Arrays
506	if (isSubtypeOf(item1.type, ValueType.ARRAY) && isSubtypeOf(item2.type, ValueType.ARRAY)) {	348,048✔
507	return arrayTypeDeepEqual(	7,521✔
508	dynamicContext,
509	executionParameters,
510	staticContext,
511	item1 as ArrayValue,
512	item2 as ArrayValue
513	);
514	}
515
516	// Nodes
517	if (isSubtypeOf(item1.type, ValueType.NODE) && isSubtypeOf(item2.type, ValueType.NODE)) {	340,527✔
518	// Document nodes
519	if (	340,482✔
520	isSubtypeOf(item1.type, ValueType.DOCUMENTNODE) &&	342,789✔
521	isSubtypeOf(item2.type, ValueType.DOCUMENTNODE)
522	) {
523	return nodeDeepEqual(dynamicContext, executionParameters, staticContext, item1, item2);	2,307✔
524	}
525
526	// Element nodes, cannot be compared due to missing schema information
527	if (	338,175✔
528	isSubtypeOf(item1.type, ValueType.ELEMENT) &&	635,094✔
529	isSubtypeOf(item2.type, ValueType.ELEMENT)
530	) {
531	return elementNodeDeepEqual(	296,919✔
532	dynamicContext,
533	executionParameters,
534	staticContext,
535	item1,
536	item2
537	);
538	}
539
540	// Attribute nodes
541	if (	41,256✔
542	isSubtypeOf(item1.type, ValueType.ATTRIBUTE) &&	81,525✔
543	isSubtypeOf(item2.type, ValueType.ATTRIBUTE)
544	) {
545	return atomicTypeNodeDeepEqual(	40,269✔
546	dynamicContext,
547	executionParameters,
548	staticContext,
549	item1,
550	item2
551	);
552	}
553
554	// Processing instruction node
555	if (	987✔
556	isSubtypeOf(item1.type, ValueType.PROCESSINGINSTRUCTION) &&	1,503✔
557	isSubtypeOf(item2.type, ValueType.PROCESSINGINSTRUCTION)
558	) {
559	return atomicTypeNodeDeepEqual(	516✔
560	dynamicContext,
561	executionParameters,
562	staticContext,
563	item1,
564	item2
565	);
566	}
567
568	// Comment nodes
569	if (	471!
570	isSubtypeOf(item1.type, ValueType.COMMENT) &&	942✔
571	isSubtypeOf(item2.type, ValueType.COMMENT)
572	) {
573	return atomicTypeNodeDeepEqual(	471✔
574	dynamicContext,
575	executionParameters,
576	staticContext,
577	item1,
578	item2
579	);
580	}
581
582	// TextNodes
583	}
584
585	return createSingleValueIterator(false);	45✔
586	}
587
588	export default sequenceDeepEqual;	18✔

FontoXML / fontoxpath / 1422978406

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