590184715

Build Type

push

github

Committed by Martin Middel

Commit Message

Fix tons of linter errors

Run Details

4691 of 5073 branches covered (92.47%)

Branch coverage included in aggregate %.

263 of 266 new or added lines in 67 files covered. (98.87%)

28 existing lines in 9 files now uncovered.

9080 of 9387 relevant lines covered (96.73%)

1252201.34 hits per line

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

91.67

/src/expressions/operators/types/CastAsOperator.ts

import atomize from '../../dataTypes/atomize';
import castToType from '../../dataTypes/castToType';
import sequenceFactory from '../../dataTypes/sequenceFactory';
import { ValueType } from '../../dataTypes/Value';
import Expression from '../../Expression';

class CastAsOperator extends Expression {
        public _allowsEmptySequence: boolean;
        public _expression: Expression;
        public _targetType: ValueType;

        constructor(
                expression: Expression,
                targetType: { localName: string; namespaceURI: string | null; prefix: string },
                allowsEmptySequence: boolean
        ) {
                super(expression.specificity, [expression], { canBeStaticallyEvaluated: false });
                this._targetType = (targetType.prefix
                        ? `${targetType.prefix}:${targetType.localName}`
                        : targetType.localName) as ValueType;
                if (
                        this._targetType === 'xs:anyAtomicType' ||
                        this._targetType === 'xs:anySimpleType' ||
                        this._targetType === 'xs:NOTATION'
                ) {
                        throw new Error(
                                'XPST0080: Casting to xs:anyAtomicType, xs:anySimpleType or xs:NOTATION is not permitted.'
                        );
                }

                if (targetType.namespaceURI) {
                        throw new Error('Not implemented: casting expressions with a namespace URI.');
                }

                this._expression = expression;
                this._allowsEmptySequence = allowsEmptySequence;
        }

        public evaluate(dynamicContext, executionParameters) {
                const evaluatedExpression = atomize(
                        this._expression.evaluateMaybeStatically(dynamicContext, executionParameters),
                        executionParameters
                );
                return evaluatedExpression.switchCases({
                        empty: () => {
                                if (!this._allowsEmptySequence) {
                                        throw new Error(
                                                'XPTY0004: Sequence to cast is empty while target type is singleton.'
                                        );
                                }
                                return sequenceFactory.empty();
                        },
                        singleton: () => {
                                return evaluatedExpression.map((value) => castToType(value, this._targetType));
                        },
                        multiple: () => {
                                throw new Error('XPTY0004: Sequence to cast is not singleton or empty.');
                        },
                });
        }
}

export default CastAsOperator;

1	import atomize from '../../dataTypes/atomize';	5✔
2	import castToType from '../../dataTypes/castToType';	5✔
3	import sequenceFactory from '../../dataTypes/sequenceFactory';	5✔
4	import { ValueType } from '../../dataTypes/Value';
5	import Expression from '../../Expression';	5✔
6
7	class CastAsOperator extends Expression {	5✔
8	public _allowsEmptySequence: boolean;
9	public _expression: Expression;
10	public _targetType: ValueType;
11
12	constructor(
13	expression: Expression,
14	targetType: { localName: string; namespaceURI: string \| null; prefix: string },
15	allowsEmptySequence: boolean
16	) {
17	super(expression.specificity, [expression], { canBeStaticallyEvaluated: false });	1,299✔
18	this._targetType = (targetType.prefix	1,299✔
19	? `${targetType.prefix}:${targetType.localName}`	1,299!
20	: targetType.localName) as ValueType;
21	if (	1,299✔
22	this._targetType === 'xs:anyAtomicType' \|\|	3,894✔
23	this._targetType === 'xs:anySimpleType' \|\|
24	this._targetType === 'xs:NOTATION'
25	) {
26	throw new Error(	7✔
27	'XPST0080: Casting to xs:anyAtomicType, xs:anySimpleType or xs:NOTATION is not permitted.'
28	);
29	}
30
31	if (targetType.namespaceURI) {	1,292!
UNCOV 32	throw new Error('Not implemented: casting expressions with a namespace URI.');	×
33	}
34
35	this._expression = expression;	1,292✔
36	this._allowsEmptySequence = allowsEmptySequence;	1,292✔
37	}
38
39	public evaluate(dynamicContext, executionParameters) {	1,336✔
40	const evaluatedExpression = atomize(	1,336✔
41	this._expression.evaluateMaybeStatically(dynamicContext, executionParameters),
42	executionParameters
43	);
44	return evaluatedExpression.switchCases({	1,332✔
45	empty: () => {
46	if (!this._allowsEmptySequence) {	8✔
47	throw new Error(	4✔
48	'XPTY0004: Sequence to cast is empty while target type is singleton.'
49	);
50	}
51	return sequenceFactory.empty();	4✔
52	},
53	singleton: () => {
54	return evaluatedExpression.map((value) => castToType(value, this._targetType));	1,321✔
55	},
56	multiple: () => {
57	throw new Error('XPTY0004: Sequence to cast is not singleton or empty.');	3✔
58	},
59	});
60	}
61	}	5✔
62
63	export default CastAsOperator;	5✔

FontoXML / fontoxpath / 590184715

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