1149901001

Build Type

github

Committed by GitHub

Commit Message

Merge 6910a45b2 into c44a09941

Pull Request Pull Request #397: Compare jscodegen

Run Details

4741 of 5093 branches covered (93.09%)

Branch coverage included in aggregate %.

332 of 345 new or added lines in 14 files covered. (96.23%)

1 existing line in 1 file now uncovered.

9426 of 9656 relevant lines covered (97.62%)

5613065.01 hits per line

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

97.82

/src/expressions/operators/compares/valueCompare.ts

import ISequence from '../../../expressions/dataTypes/ISequence';
import { ValueType, valueTypeToString } from '../../../expressions/dataTypes/Value';
import AtomicValue from '../../dataTypes/AtomicValue';
import castToType from '../../dataTypes/castToType';
import isSubtypeOf from '../../dataTypes/isSubtypeOf';
import {
        equal as dateTimeEqual,
        greaterThan as dateTimeGreaterThan,
        lessThan as dateTimeLessThan,
} from '../../dataTypes/valueTypes/DateTime';
import {
        greaterThan as dayTimeDurationGreaterThan,
        lessThan as dayTimeDurationLessThan,
} from '../../dataTypes/valueTypes/DayTimeDuration';
import {
        greaterThan as yearMonthDurationGreaterThan,
        lessThan as yearMonthDurationLessThan,
} from '../../dataTypes/valueTypes/YearMonthDuration';
import DynamicContext from '../../DynamicContext';

function handleQName(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        if (operator === 'eqOp') {
                return (a, b, _dynamicContext) => {
                        const { castA, castB } = applyCastFunctions(a, b);
                        return (
                                castA.value.namespaceURI === castB.value.namespaceURI &&
                                castA.value.localName === castB.value.localName
                        );
                };
        }
        if (operator === 'neOp') {
                return (a, b, _dynamicContext) => {
                        const { castA, castB } = applyCastFunctions(a, b);
                        return (
                                castA.value.namespaceURI !== castB.value.namespaceURI ||
                                castA.value.localName !== castB.value.localName
                        );
                };
        }
        throw new Error('XPTY0004: Only the "eq" and "ne" comparison is defined for xs:QName');
}

function handleNumeric(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        switch (operator) {
                case 'eqOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value === castB.value;
                        };
                case 'neOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value !== castB.value;
                        };
                case 'ltOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value < castB.value;
                        };
                case 'leOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value <= castB.value;
                        };
                case 'gtOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value > castB.value;
                        };
                case 'geOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value >= castB.value;
                        };
                default:
                        return undefined;
        }
}

function handleYearMonthDuration(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        switch (operator) {
                case 'ltOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return yearMonthDurationLessThan(castA.value, castB.value);
                        };
                case 'leOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return (
                                        castA.value.equals(castB.value) ||
                                        yearMonthDurationLessThan(castA.value, castB.value)
                                );
                        };

                case 'gtOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return yearMonthDurationGreaterThan(castA.value, castB.value);
                        };
                case 'geOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return (
                                        castA.value.equals(castB.value) ||
                                        yearMonthDurationGreaterThan(castA.value, castB.value)
                                );
                        };
                default:
                        return undefined;
        }
}

function handleDayTimeDuration(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        switch (operator) {
                case 'eqOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value.equals(castB.value);
                        };
                case 'ltOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return dayTimeDurationLessThan(castA.value, castB.value);
                        };
                case 'leOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return (
                                        castA.value.equals(castB.value) ||
                                        dayTimeDurationLessThan(castA.value, castB.value)
                                );
                        };
                case 'gtOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return dayTimeDurationGreaterThan(castA.value, castB.value);
                        };
                case 'geOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return (
                                        castA.value.equals(castB.value) ||
                                        dayTimeDurationGreaterThan(castA.value, castB.value)
                                );
                        };
                default:
                        return undefined;
        }
}

function handleDuration(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        switch (operator) {
                case 'eqOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return castA.value.equals(castB.value);
                        };
                case 'neOp':
                        return (a, b, _dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return !castA.value.equals(castB.value);
                        };
                default:
                        return undefined;
        }
}

function handleDateAndTime(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        switch (operator) {
                case 'eqOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return dateTimeEqual(
                                        castA.value,
                                        castB.value,
                                        dynamicContext.getImplicitTimezone()
                                );
                        };
                case 'neOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return !dateTimeEqual(
                                        castA.value,
                                        castB.value,
                                        dynamicContext.getImplicitTimezone()
                                );
                        };

                case 'ltOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return dateTimeLessThan(
                                        castA.value,
                                        castB.value,
                                        dynamicContext.getImplicitTimezone()
                                );
                        };
                case 'leOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return (
                                        dateTimeEqual(castA.value, castB.value, dynamicContext.getImplicitTimezone()) ||
                                        dateTimeLessThan(castA.value, castB.value, dynamicContext.getImplicitTimezone())
                                );
                        };

                case 'gtOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return dateTimeGreaterThan(
                                        castA.value,
                                        castB.value,
                                        dynamicContext.getImplicitTimezone()
                                );
                        };
                case 'geOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return (
                                        dateTimeEqual(castA.value, castB.value, dynamicContext.getImplicitTimezone()) ||
                                        dateTimeGreaterThan(
                                                castA.value,
                                                castB.value,
                                                dynamicContext.getImplicitTimezone()
                                        )
                                );
                        };
                default:
                        return undefined;
        }
}

function handleDayMonthAndYear(
        operator: string,
        applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        switch (operator) {
                case 'eqOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return dateTimeEqual(
                                        castA.value,
                                        castB.value,
                                        dynamicContext.getImplicitTimezone()
                                );
                        };
                case 'neOp':
                        return (a, b, dynamicContext) => {
                                const { castA, castB } = applyCastFunctions(a, b);
                                return !dateTimeEqual(
                                        castA.value,
                                        castB.value,
                                        dynamicContext.getImplicitTimezone()
                                );
                        };
                default:
                        return undefined;
        }
}

function generateCompareFunction(
        operator: string,
        typeA: ValueType,
        typeB: ValueType
): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
        let castFunctionForValueA: (x: AtomicValue) => AtomicValue = null;
        let castFunctionForValueB: (x: AtomicValue) => AtomicValue = null;

        if (
                isSubtypeOf(typeA, ValueType.XSUNTYPEDATOMIC) &&
                isSubtypeOf(typeB, ValueType.XSUNTYPEDATOMIC)
        ) {
                typeA = typeB = ValueType.XSSTRING;
        } else if (isSubtypeOf(typeA, ValueType.XSUNTYPEDATOMIC)) {
                castFunctionForValueA = (val: AtomicValue) => castToType(val, typeB);
                typeA = typeB;
        } else if (isSubtypeOf(typeB, ValueType.XSUNTYPEDATOMIC)) {
                castFunctionForValueB = (val: AtomicValue) => castToType(val, typeA);
                typeB = typeA;
        }

        function applyCastFunctions(valA: AtomicValue, valB: AtomicValue) {
                return {
                        castA: castFunctionForValueA ? castFunctionForValueA(valA) : valA,
                        castB: castFunctionForValueB ? castFunctionForValueB(valB) : valB,
                };
        }

        if (isSubtypeOf(typeA, ValueType.XSQNAME) && isSubtypeOf(typeB, ValueType.XSQNAME)) {
                return handleQName(operator, applyCastFunctions);
        }

        function areBothSubtypeOf(type: ValueType) {
                return isSubtypeOf(typeA, type) && isSubtypeOf(typeB, type);
        }

        function areBothSubtypeOfOne(types: ValueType[]) {
                return (
                        types.filter((x) => isSubtypeOf(typeA, x)).length > 0 &&
                        types.filter((x) => isSubtypeOf(typeB, x)).length > 0
                );
        }

        if (
                areBothSubtypeOf(ValueType.XSBOOLEAN) ||
                // If something is marked as an attribute its either a string or a number
                areBothSubtypeOfOne([ValueType.XSSTRING, ValueType.ATTRIBUTE, ValueType.MAP]) ||
                areBothSubtypeOfOne([ValueType.XSNUMERIC, ValueType.ATTRIBUTE, ValueType.MAP]) ||
                areBothSubtypeOf(ValueType.XSANYURI) ||
                areBothSubtypeOf(ValueType.XSHEXBINARY) ||
                areBothSubtypeOf(ValueType.XSBASE64BINARY) ||
                areBothSubtypeOfOne([ValueType.XSSTRING, ValueType.XSANYURI])
        ) {
                const result = handleNumeric(operator, applyCastFunctions);
                if (result !== undefined) {
                        return result;
                }
        }

        if (areBothSubtypeOf(ValueType.XSYEARMONTHDURATION)) {
                const result = handleYearMonthDuration(operator, applyCastFunctions);
                if (result !== undefined) {
                        return result;
                }
        }

        if (areBothSubtypeOf(ValueType.XSDAYTIMEDURATION)) {
                const result = handleDayTimeDuration(operator, applyCastFunctions);
                if (result !== undefined) {
                        return result;
                }
        }

        if (areBothSubtypeOf(ValueType.XSDURATION)) {
                const result = handleDuration(operator, applyCastFunctions);
                if (result !== undefined) {
                        return result;
                }
        }

        if (
                areBothSubtypeOf(ValueType.XSDATETIME) ||
                areBothSubtypeOf(ValueType.XSDATE) ||
                areBothSubtypeOf(ValueType.XSTIME)
        ) {
                const result = handleDateAndTime(operator, applyCastFunctions);
                if (result !== undefined) {
                        return result;
                }
        }

        if (
                areBothSubtypeOf(ValueType.XSGYEARMONTH) ||
                areBothSubtypeOf(ValueType.XSGYEAR) ||
                areBothSubtypeOf(ValueType.XSGMONTHDAY) ||
                areBothSubtypeOf(ValueType.XSGMONTH) ||
                areBothSubtypeOf(ValueType.XSGDAY)
        ) {
                const result = handleDayMonthAndYear(operator, applyCastFunctions);
                if (result !== undefined) {
                        return result;
                }
        }

        throw new Error(
                `XPTY0004: ${operator} not available for ${valueTypeToString(
                        typeA
                )} and ${valueTypeToString(typeB)}`
        );
}

const comparatorsByTypingKey = Object.create(null);

function valueCompare(
        operator: string,
        typeA: ValueType,
        typeB: ValueType
): (valueA: AtomicValue, valueB: AtomicValue, dynamicContext: DynamicContext) => boolean {
        // https://www.w3.org/TR/xpath-3/#doc-xpath31-ValueComp
        const typingKey = `${typeA as number}~${typeB as number}~${operator}`;
        let prefabComparator = comparatorsByTypingKey[typingKey];
        if (!prefabComparator) {
                prefabComparator = comparatorsByTypingKey[typingKey] = generateCompareFunction(
                        operator,
                        typeA,
                        typeB
                );
        }

        return prefabComparator;
}

export function getValueCompareEvaluationFunction(
        operator: string,
        typeA: ValueType,
        typeB: ValueType
): (
        firstSequence: ISequence,
        secondSequence: ISequence,
        dynamicContext: DynamicContext
) => boolean {
        try {
                const evaluationFunction = valueCompare(operator, typeA, typeB);

                return (first, second, dynamicContext) => {
                        if (first.getLength() > 1 || second.getLength() > 1) {
                                throw new Error('XPTY0004: Sequences to compare are not singleton.');
                        }

                        return evaluationFunction(first.first(), second.first(), dynamicContext);
                };
        } catch {
                return undefined;
        }
}

export default valueCompare;

1	import ISequence from '../../../expressions/dataTypes/ISequence';
2	import { ValueType, valueTypeToString } from '../../../expressions/dataTypes/Value';	18✔
3	import AtomicValue from '../../dataTypes/AtomicValue';
4	import castToType from '../../dataTypes/castToType';	18✔
5	import isSubtypeOf from '../../dataTypes/isSubtypeOf';	18✔
6	import {	18✔
7	equal as dateTimeEqual,
8	greaterThan as dateTimeGreaterThan,
9	lessThan as dateTimeLessThan,
10	} from '../../dataTypes/valueTypes/DateTime';
11	import {	18✔
12	greaterThan as dayTimeDurationGreaterThan,
13	lessThan as dayTimeDurationLessThan,
14	} from '../../dataTypes/valueTypes/DayTimeDuration';
15	import {	18✔
16	greaterThan as yearMonthDurationGreaterThan,
17	lessThan as yearMonthDurationLessThan,
18	} from '../../dataTypes/valueTypes/YearMonthDuration';
19	import DynamicContext from '../../DynamicContext';
20
21	function handleQName(
22	operator: string,
23	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
24	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
25	if (operator === 'eqOp') {	66✔
26	return (a, b, _dynamicContext) => {	9✔
27	const { castA, castB } = applyCastFunctions(a, b);	420✔
28	return (	420✔
29	castA.value.namespaceURI === castB.value.namespaceURI &&	813✔
30	castA.value.localName === castB.value.localName
31	);
32	};
33	}
34	if (operator === 'neOp') {	57✔
35	return (a, b, _dynamicContext) => {	9✔
36	const { castA, castB } = applyCastFunctions(a, b);	96✔
37	return (	96✔
38	castA.value.namespaceURI !== castB.value.namespaceURI \|\|	159✔
39	castA.value.localName !== castB.value.localName
40	);
41	};
42	}
43	throw new Error('XPTY0004: Only the "eq" and "ne" comparison is defined for xs:QName');	48✔
44	}
45
46	function handleNumeric(
47	operator: string,
48	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
49	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
50	switch (operator) {	4,317✔
51	case 'eqOp':	4,317✔
52	return (a, b, _dynamicContext) => {	396✔
53	const { castA, castB } = applyCastFunctions(a, b);	11,148,828✔
54	return castA.value === castB.value;	11,148,813✔
55	};
56	case 'neOp':
57	return (a, b, _dynamicContext) => {	210✔
58	const { castA, castB } = applyCastFunctions(a, b);	1,882,056✔
59	return castA.value !== castB.value;	1,882,044✔
60	};
61	case 'ltOp':
62	return (a, b, _dynamicContext) => {	189✔
63	const { castA, castB } = applyCastFunctions(a, b);	14,862✔
64	return castA.value < castB.value;	14,862✔
65	};
66	case 'leOp':
67	return (a, b, _dynamicContext) => {	120✔
68	const { castA, castB } = applyCastFunctions(a, b);	4,761✔
69	return castA.value <= castB.value;	4,761✔
70	};
71	case 'gtOp':
72	return (a, b, _dynamicContext) => {	171✔
73	const { castA, castB } = applyCastFunctions(a, b);	2,471,385✔
74	return castA.value > castB.value;	2,471,385✔
75	};
76	case 'geOp':
77	return (a, b, _dynamicContext) => {	144✔
78	const { castA, castB } = applyCastFunctions(a, b);	8,865✔
79	return castA.value >= castB.value;	8,865✔
80	};
81	default:
82	return undefined;	3,087✔
83	}
84	}
85
86	function handleYearMonthDuration(
87	operator: string,
88	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
89	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
90	switch (operator) {	51✔
91	case 'ltOp':	51✔
92	return (a, b, _dynamicContext) => {	9✔
93	const { castA, castB } = applyCastFunctions(a, b);	129✔
94	return yearMonthDurationLessThan(castA.value, castB.value);	129✔
95	};
96	case 'leOp':
97	return (a, b, _dynamicContext) => {	6✔
98	const { castA, castB } = applyCastFunctions(a, b);	174✔
99	return (	174✔
100	castA.value.equals(castB.value) \|\|	312✔
101	yearMonthDurationLessThan(castA.value, castB.value)
102	);
103	};
104
105	case 'gtOp':
106	return (a, b, _dynamicContext) => {	9✔
107	const { castA, castB } = applyCastFunctions(a, b);	135✔
108	return yearMonthDurationGreaterThan(castA.value, castB.value);	135✔
109	};
110	case 'geOp':
111	return (a, b, _dynamicContext) => {	6✔
112	const { castA, castB } = applyCastFunctions(a, b);	174✔
113	return (	174✔
114	castA.value.equals(castB.value) \|\|	312✔
115	yearMonthDurationGreaterThan(castA.value, castB.value)
116	);
117	};
118	default:
119	return undefined;	21✔
120	}
121	}
122
123	function handleDayTimeDuration(
124	operator: string,
125	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
126	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
127	switch (operator) {	51✔
128	case 'eqOp':	51✔
129	return (a, b, _dynamicContext) => {	15✔
130	const { castA, castB } = applyCastFunctions(a, b);	585✔
131	return castA.value.equals(castB.value);	585✔
132	};
133	case 'ltOp':
134	return (a, b, _dynamicContext) => {	9✔
135	const { castA, castB } = applyCastFunctions(a, b);	123✔
136	return dayTimeDurationLessThan(castA.value, castB.value);	123✔
137	};
138	case 'leOp':
139	return (a, b, _dynamicContext) => {	6✔
140	const { castA, castB } = applyCastFunctions(a, b);	228✔
141	return (	228✔
142	castA.value.equals(castB.value) \|\|	390✔
143	dayTimeDurationLessThan(castA.value, castB.value)
144	);
145	};
146	case 'gtOp':
147	return (a, b, _dynamicContext) => {	9✔
148	const { castA, castB } = applyCastFunctions(a, b);	141✔
149	return dayTimeDurationGreaterThan(castA.value, castB.value);	141✔
150	};
151	case 'geOp':
152	return (a, b, _dynamicContext) => {	6✔
153	const { castA, castB } = applyCastFunctions(a, b);	198✔
154	return (	198✔
155	castA.value.equals(castB.value) \|\|	360✔
156	dayTimeDurationGreaterThan(castA.value, castB.value)
157	);
158	};
159	default:
160	return undefined;	6✔
161	}
162	}
163
164	function handleDuration(
165	operator: string,
166	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
167	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
168	switch (operator) {	498✔
169	case 'eqOp':	498✔
170	return (a, b, _dynamicContext) => {	60✔
171	const { castA, castB } = applyCastFunctions(a, b);	471✔
172	return castA.value.equals(castB.value);	471✔
173	};
174	case 'neOp':
175	return (a, b, _dynamicContext) => {	54✔
176	const { castA, castB } = applyCastFunctions(a, b);	366✔
177	return !castA.value.equals(castB.value);	366✔
178	};
179	default:
180	return undefined;	384✔
181	}
182	}
183
184	function handleDateAndTime(
185	operator: string,
186	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
187	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
188	switch (operator) {	126✔
189	case 'eqOp':	126!
190	return (a, b, dynamicContext) => {	42✔
191	const { castA, castB } = applyCastFunctions(a, b);	657✔
192	return dateTimeEqual(	657✔
193	castA.value,
194	castB.value,
195	dynamicContext.getImplicitTimezone()
196	);
197	};
198	case 'neOp':
199	return (a, b, dynamicContext) => {	18✔
200	const { castA, castB } = applyCastFunctions(a, b);	198✔
201	return !dateTimeEqual(	198✔
202	castA.value,
203	castB.value,
204	dynamicContext.getImplicitTimezone()
205	);
206	};
207
208	case 'ltOp':
209	return (a, b, dynamicContext) => {	21✔
210	const { castA, castB } = applyCastFunctions(a, b);	405✔
211	return dateTimeLessThan(	405✔
212	castA.value,
213	castB.value,
214	dynamicContext.getImplicitTimezone()
215	);
216	};
217	case 'leOp':
218	return (a, b, dynamicContext) => {	12✔
219	const { castA, castB } = applyCastFunctions(a, b);	426✔
220	return (	426✔
221	dateTimeEqual(castA.value, castB.value, dynamicContext.getImplicitTimezone()) \|\|	762✔
222	dateTimeLessThan(castA.value, castB.value, dynamicContext.getImplicitTimezone())
223	);
224	};
225
226	case 'gtOp':
227	return (a, b, dynamicContext) => {	21✔
228	const { castA, castB } = applyCastFunctions(a, b);	981✔
229	return dateTimeGreaterThan(	981✔
230	castA.value,
231	castB.value,
232	dynamicContext.getImplicitTimezone()
233	);
234	};
235	case 'geOp':
236	return (a, b, dynamicContext) => {	12✔
237	const { castA, castB } = applyCastFunctions(a, b);	396✔
238	return (	396✔
239	dateTimeEqual(castA.value, castB.value, dynamicContext.getImplicitTimezone()) \|\|	720✔
240	dateTimeGreaterThan(
241	castA.value,
242	castB.value,
243	dynamicContext.getImplicitTimezone()
244	)
245	);
246	};
247	default:
NEW 248	return undefined;	×
249	}
250	}
251
252	function handleDayMonthAndYear(
253	operator: string,
254	applyCastFunctions: (valA: AtomicValue, valB: AtomicValue) => any
255	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
256	switch (operator) {	75✔
257	case 'eqOp':	75!
258	return (a, b, dynamicContext) => {	45✔
259	const { castA, castB } = applyCastFunctions(a, b);	1,071✔
260	return dateTimeEqual(	1,071✔
261	castA.value,
262	castB.value,
263	dynamicContext.getImplicitTimezone()
264	);
265	};
266	case 'neOp':
267	return (a, b, dynamicContext) => {	30✔
268	const { castA, castB } = applyCastFunctions(a, b);	696✔
269	return !dateTimeEqual(	696✔
270	castA.value,
271	castB.value,
272	dynamicContext.getImplicitTimezone()
273	);
274	};
275	default:
NEW 276	return undefined;	×
277	}
278	}
279
280	function generateCompareFunction(
281	operator: string,
282	typeA: ValueType,
283	typeB: ValueType
284	): (valA: any, valB: any, dynamicContext: DynamicContext) => boolean {
285	let castFunctionForValueA: (x: AtomicValue) => AtomicValue = null;	5,985✔
286	let castFunctionForValueB: (x: AtomicValue) => AtomicValue = null;	5,985✔
287
288	if (	5,985✔
289	isSubtypeOf(typeA, ValueType.XSUNTYPEDATOMIC) &&	6,105✔
290	isSubtypeOf(typeB, ValueType.XSUNTYPEDATOMIC)
291	) {
292	typeA = typeB = ValueType.XSSTRING;	42✔
293	} else if (isSubtypeOf(typeA, ValueType.XSUNTYPEDATOMIC)) {	5,943✔
294	castFunctionForValueA = (val: AtomicValue) => castToType(val, typeB);	2,832✔
295	typeA = typeB;	78✔
296	} else if (isSubtypeOf(typeB, ValueType.XSUNTYPEDATOMIC)) {	5,865✔
297	castFunctionForValueB = (val: AtomicValue) => castToType(val, typeA);	135✔
298	typeB = typeA;	69✔
299	}
300
301	function applyCastFunctions(valA: AtomicValue, valB: AtomicValue) {
302	return {	15,538,827✔
303	castA: castFunctionForValueA ? castFunctionForValueA(valA) : valA,	15,538,827✔
304	castB: castFunctionForValueB ? castFunctionForValueB(valB) : valB,	15,538,812✔
305	};
306	}
307
308	if (isSubtypeOf(typeA, ValueType.XSQNAME) && isSubtypeOf(typeB, ValueType.XSQNAME)) {	5,985✔
309	return handleQName(operator, applyCastFunctions);	66✔
310	}
311
312	function areBothSubtypeOf(type: ValueType) {
313	return isSubtypeOf(typeA, type) && isSubtypeOf(typeB, type);	60,063✔
314	}
315
316	function areBothSubtypeOfOne(types: ValueType[]) {
317	return (	12,519✔
318	types.filter((x) => isSubtypeOf(typeA, x)).length > 0 &&	35,889✔
319	types.filter((x) => isSubtypeOf(typeB, x)).length > 0	13,260✔
320	);
321	}
322
323	if (	5,919✔
324	areBothSubtypeOf(ValueType.XSBOOLEAN) \|\|	23,565✔
325	// If something is marked as an attribute its either a string or a number
326	areBothSubtypeOfOne([ValueType.XSSTRING, ValueType.ATTRIBUTE, ValueType.MAP]) \|\|
327	areBothSubtypeOfOne([ValueType.XSNUMERIC, ValueType.ATTRIBUTE, ValueType.MAP]) \|\|
328	areBothSubtypeOf(ValueType.XSANYURI) \|\|
329	areBothSubtypeOf(ValueType.XSHEXBINARY) \|\|
330	areBothSubtypeOf(ValueType.XSBASE64BINARY) \|\|
331	areBothSubtypeOfOne([ValueType.XSSTRING, ValueType.XSANYURI])
332	) {
333	const result = handleNumeric(operator, applyCastFunctions);	4,317✔
334	if (result !== undefined) {	4,317✔
335	return result;	1,230✔
336	}
337	}
338
339	if (areBothSubtypeOf(ValueType.XSYEARMONTHDURATION)) {	4,689✔
340	const result = handleYearMonthDuration(operator, applyCastFunctions);	51✔
341	if (result !== undefined) {	51✔
342	return result;	30✔
343	}
344	}
345
346	if (areBothSubtypeOf(ValueType.XSDAYTIMEDURATION)) {	4,659✔
347	const result = handleDayTimeDuration(operator, applyCastFunctions);	51✔
348	if (result !== undefined) {	51✔
349	return result;	45✔
350	}
351	}
352
353	if (areBothSubtypeOf(ValueType.XSDURATION)) {	4,614✔
354	const result = handleDuration(operator, applyCastFunctions);	498✔
355	if (result !== undefined) {	498✔
356	return result;	114✔
357	}
358	}
359
360	if (	4,500✔
361	areBothSubtypeOf(ValueType.XSDATETIME) \|\|	13,335✔
362	areBothSubtypeOf(ValueType.XSDATE) \|\|
363	areBothSubtypeOf(ValueType.XSTIME)
364	) {
365	const result = handleDateAndTime(operator, applyCastFunctions);	126✔
366	if (result !== undefined) {	126!
367	return result;	126✔
368	}
369	}
370
371	if (	4,374✔
372	areBothSubtypeOf(ValueType.XSGYEARMONTH) \|\|	21,720✔
373	areBothSubtypeOf(ValueType.XSGYEAR) \|\|
374	areBothSubtypeOf(ValueType.XSGMONTHDAY) \|\|
375	areBothSubtypeOf(ValueType.XSGMONTH) \|\|
376	areBothSubtypeOf(ValueType.XSGDAY)
377	) {
378	const result = handleDayMonthAndYear(operator, applyCastFunctions);	75✔
379	if (result !== undefined) {	75!
380	return result;	75✔
381	}
382	}
383
384	throw new Error(	4,299✔
385	`XPTY0004: ${operator} not available for ${valueTypeToString(
386	typeA
387	)} and ${valueTypeToString(typeB)}`
388	);
389	}
390
391	const comparatorsByTypingKey = Object.create(null);	18✔
392
393	function valueCompare(
394	operator: string,
395	typeA: ValueType,
396	typeB: ValueType
397	): (valueA: AtomicValue, valueB: AtomicValue, dynamicContext: DynamicContext) => boolean {
398	// https://www.w3.org/TR/xpath-3/#doc-xpath31-ValueComp
399	const typingKey = `${typeA as number}~${typeB as number}~${operator}`;	13,718,358✔
400	let prefabComparator = comparatorsByTypingKey[typingKey];	13,718,358✔
401	if (!prefabComparator) {	13,718,358✔
402	prefabComparator = comparatorsByTypingKey[typingKey] = generateCompareFunction(	5,985✔
403	operator,
404	typeA,
405	typeB
406	);
407	}
408
409	return prefabComparator;	13,714,011✔
410	}
411
412	export function getValueCompareEvaluationFunction(	18✔
413	operator: string,
414	typeA: ValueType,
415	typeB: ValueType
416	): (
417	firstSequence: ISequence,
418	secondSequence: ISequence,
419	dynamicContext: DynamicContext
420	) => boolean {
421	try {	11,847✔
422	const evaluationFunction = valueCompare(operator, typeA, typeB);	11,847✔
423
424	return (first, second, dynamicContext) => {	8,268✔
425	if (first.getLength() > 1 \|\| second.getLength() > 1) {	11,700✔
426	throw new Error('XPTY0004: Sequences to compare are not singleton.');	42✔
427	}
428
429	return evaluationFunction(first.first(), second.first(), dynamicContext);	11,658✔
430	};
431	} catch {
432	return undefined;	3,579✔
433	}
434	}
435
436	export default valueCompare;	18✔

FontoXML / fontoxpath / 1149901001

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