3320999782

Build # 3320999782

Build Type

github

Committed by GitHub

Commit Message

Merge 891b5ebc6 into a89c532aa

Pull Request Pull Request #552: Codegen optimizations

Run Details

4874 of 5672 branches covered (85.93%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 1 file covered. (100.0%)

26 existing lines in 6 files now uncovered.

10460 of 11098 relevant lines covered (94.25%)

32612.12 hits per line

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

86.82

/src/expressions/functions/builtInFunctions_numeric.ts

import atomize from '../dataTypes/atomize';
import tryCastToType from '../dataTypes/casting/tryCastToType';
import castToType from '../dataTypes/castToType';
import createAtomicValue from '../dataTypes/createAtomicValue';
import FunctionValue from '../dataTypes/FunctionValue';
import type ISequence from '../dataTypes/ISequence';
import isSubtypeOf from '../dataTypes/isSubtypeOf';
import MapValue from '../dataTypes/MapValue';
import sequenceFactory from '../dataTypes/sequenceFactory';
import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
import type DynamicContext from '../DynamicContext';
import type ExecutionParameters from '../ExecutionParameters';
import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
import type StaticContext from '../StaticContext';
import { DONE_TOKEN, ready } from '../util/iterators';
import { errXPDY0002 } from '../XPathErrors';
import { performFunctionConversion } from './argumentHelper';
import type { BuiltinDeclarationType } from './builtInFunctions';
import type FunctionDefinitionType from './FunctionDefinitionType';

function createValidNumericType(type: ValueType, transformedValue: number) {
        if (isSubtypeOf(type, ValueType.XSINTEGER)) {
                return createAtomicValue(transformedValue, ValueType.XSINTEGER);
        }
        if (isSubtypeOf(type, ValueType.XSFLOAT)) {
                return createAtomicValue(transformedValue, ValueType.XSFLOAT);
        }
        if (isSubtypeOf(type, ValueType.XSDOUBLE)) {
                return createAtomicValue(transformedValue, ValueType.XSDOUBLE);
        }
        // It must be a decimal, only four numeric types
        return createAtomicValue(transformedValue, ValueType.XSDECIMAL);
}

const ROMAN_NUMBERS = [
        { symbol: 'M', decimal: 1000 },
        { symbol: 'CM', decimal: 900 },
        { symbol: 'D', decimal: 500 },
        { symbol: 'CD', decimal: 400 },
        { symbol: 'C', decimal: 100 },
        { symbol: 'XC', decimal: 90 },
        { symbol: 'L', decimal: 50 },
        { symbol: 'XL', decimal: 40 },
        { symbol: 'X', decimal: 10 },
        { symbol: 'IX', decimal: 9 },
        { symbol: 'V', decimal: 5 },
        { symbol: 'IV', decimal: 4 },
        { symbol: 'I', decimal: 1 },
];

function convertIntegerToRoman(integer: string, isLowerCase?: boolean) {
        let int = parseInt(integer, 10);

        const isNegative = int < 0;

        int = Math.abs(int);

        if (!int) {
                return '-';
        }

        let romanString = ROMAN_NUMBERS.reduce((str, roman) => {
                const q = Math.floor(int / roman.decimal);
                int -= q * roman.decimal;
                return str + roman.symbol.repeat(q);
        }, '');

        if (isLowerCase) {
                romanString = romanString.toLowerCase();
        }

        if (isNegative) {
                romanString = `-${romanString}`;
        }

        return romanString;
}

const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');

function convertIntegerToAlphabet(integer: string, isLowerCase?: boolean) {
        let int = parseInt(integer, 10);

        const isNegative = int < 0;

        int = Math.abs(int);

        if (!int) {
                return '-';
        }

        let output = '';
        let digit;

        while (int > 0) {
                digit = (int - 1) % ALPHABET.length;
                output = ALPHABET[digit] + output;
                int = ((int - digit) / ALPHABET.length) | 0;
        }

        if (isLowerCase) {
                output = output.toLowerCase();
        }

        if (isNegative) {
                output = `-${output}`;
        }

        return output;
}

const fnAbs: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        return sequence.map((onlyValue) =>
                createValidNumericType(onlyValue.type, Math.abs(onlyValue.value))
        );
};

const fnFormatInteger: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence,
        pictureSequence
) => {
        const sequenceValue = sequence.first();
        const pictureValue = pictureSequence.first();

        if (sequence.isEmpty()) {
                return sequenceFactory.singleton(createAtomicValue('', ValueType.XSSTRING));
        }

        switch (pictureValue.value) {
                case 'I': {
                        const romanString = convertIntegerToRoman(sequenceValue.value);
                        return sequenceFactory.singleton(createAtomicValue(romanString, ValueType.XSSTRING));
                }
                case 'i': {
                        const romanString = convertIntegerToRoman(sequenceValue.value, true);
                        return sequenceFactory.singleton(createAtomicValue(romanString, ValueType.XSSTRING));
                }
                case 'A': {
                        const alphabetString = convertIntegerToAlphabet(sequenceValue.value);
                        return sequenceFactory.singleton(createAtomicValue(alphabetString, ValueType.XSSTRING));
                }
                case 'a': {
                        const alphabetString = convertIntegerToAlphabet(sequenceValue.value, true);
                        return sequenceFactory.singleton(createAtomicValue(alphabetString, ValueType.XSSTRING));
                }
                default:
                        throw new Error(
                                `Picture: ${pictureValue.value} is not implemented yet. The supported picture strings are "A", "a", "I", and "i"`
                        );
        }
};

const fnCeiling: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        return sequence.map((onlyValue) =>
                createValidNumericType(onlyValue.type, Math.ceil(onlyValue.value))
        );
};

const fnFloor: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        return sequence.map((onlyValue) =>
                createValidNumericType(onlyValue.type, Math.floor(onlyValue.value))
        );
};

function isHalf(value: number, scaling: number) {
        return ((value * scaling) % 1) % 0.5 === 0;
}

function getNumberOfDecimalDigits(value: number) {
        if (Math.floor(value) === value || isNaN(value)) {
                return 0;
        }

        const result = /\d+(?:\.(\d*))?(?:[Ee](-)?(\d+))*/.exec(`${value}`);
        const decimals = result[1] ? result[1].length : 0;

        if (result[3]) {
                if (result[2]) {
                        return decimals + parseInt(result[3], 10);
                }
                const returnVal = decimals - parseInt(result[3], 10);
                return returnVal < 0 ? 0 : returnVal;
        }
        return decimals;
}

function determineRoundedNumber(itemAsDecimal: number, halfToEven: boolean, scaling: number) {
        if (halfToEven && isHalf(itemAsDecimal, scaling)) {
                if (Math.floor(itemAsDecimal * scaling) % 2 === 0) {
                        return Math.floor(itemAsDecimal * scaling) / scaling;
                }
                return Math.ceil(itemAsDecimal * scaling) / scaling;
        }
        return Math.round(itemAsDecimal * scaling) / scaling;
}

function fnRound(
        halfToEven: boolean,
        _dynamicContext: DynamicContext,
        _executionParameters: ExecutionParameters,
        _staticContext: StaticContext,
        sequence: ISequence,
        precision: ISequence
): ISequence {
        let done = false;
        return sequenceFactory.create({
                next: () => {
                        if (done) {
                                return DONE_TOKEN;
                        }
                        const firstValue = sequence.first();
                        if (!firstValue) {
                                // Empty sequence
                                done = true;
                                return DONE_TOKEN;
                        }

                        if (
                                (isSubtypeOf(firstValue.type, ValueType.XSFLOAT) ||
                                        isSubtypeOf(firstValue.type, ValueType.XSDOUBLE)) &&
                                (firstValue.value === 0 ||
                                        isNaN(firstValue.value as number) ||
                                        firstValue.value === +Infinity ||
                                        firstValue.value === -Infinity)
                        ) {
                                done = true;
                                return ready(firstValue);
                        }
                        let scalingPrecision;
                        if (precision) {
                                const sp = precision.first();
                                scalingPrecision = sp.value;
                        } else {
                                scalingPrecision = 0;
                        }
                        done = true;

                        if (getNumberOfDecimalDigits(firstValue.value as number) < scalingPrecision) {
                                return ready(firstValue);
                        }

                        const originalType = [
                                ValueType.XSINTEGER,
                                ValueType.XSDECIMAL,
                                ValueType.XSDOUBLE,
                                ValueType.XSFLOAT,
                        ].find((type: ValueType) => {
                                return isSubtypeOf(firstValue.type, type);
                        });
                        const itemAsDecimal = castToType(firstValue, ValueType.XSDECIMAL);
                        const scaling = Math.pow(10, scalingPrecision);
                        const roundedNumber = determineRoundedNumber(itemAsDecimal.value, halfToEven, scaling);
                        switch (originalType) {
                                case ValueType.XSDECIMAL:
                                        return ready(createAtomicValue(roundedNumber, ValueType.XSDECIMAL));
                                case ValueType.XSDOUBLE:
                                        return ready(createAtomicValue(roundedNumber, ValueType.XSDOUBLE));
                                case ValueType.XSFLOAT:
                                        return ready(createAtomicValue(roundedNumber, ValueType.XSFLOAT));
                                case ValueType.XSINTEGER:
                                        return ready(createAtomicValue(roundedNumber, ValueType.XSINTEGER));
                        }
                },
        });
}

const fnNumber: FunctionDefinitionType = (
        _dynamicContext,
        executionParameters,
        _staticContext,
        sequence
) => {
        return atomize(sequence, executionParameters).switchCases({
                empty: () => sequenceFactory.singleton(createAtomicValue(NaN, ValueType.XSDOUBLE)),
                singleton: () => {
                        const castResult = tryCastToType(sequence.first(), ValueType.XSDOUBLE);
                        if (castResult.successful) {
                                return sequenceFactory.singleton(castResult.value);
                        }
                        return sequenceFactory.singleton(createAtomicValue(NaN, ValueType.XSDOUBLE));
                },
                multiple: () => {
                        throw new Error('fn:number may only be called with zero or one values');
                },
        });
};

const permute: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty() || sequence.isSingleton()) {
                return sequence;
        }

        const a = sequence.getAllValues();

        // Use Durstenfeld shuffle to randomize the list
        for (let i = a.length - 1; i > 1; i--) {
                const j = Math.floor(Math.random() * (i + 1));
                const t = a[j];
                a[j] = a[i];
                a[i] = t;
        }

        return sequenceFactory.create(a);
};

const fnRandomNumberGenerator: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        _sequence
) => {
        // Ignore the optional seed, as Math.random does not support a seed
        return sequenceFactory.singleton(
                new MapValue([
                        {
                                key: createAtomicValue('number', ValueType.XSSTRING),
                                value: () =>
                                        sequenceFactory.singleton(createAtomicValue(Math.random(), ValueType.XSDOUBLE)),
                        },
                        {
                                key: createAtomicValue('next', ValueType.XSSTRING),
                                value: () =>
                                        sequenceFactory.singleton(
                                                new FunctionValue({
                                                        value: fnRandomNumberGenerator,
                                                        isAnonymous: true,
                                                        localName: '',
                                                        namespaceURI: '',
                                                        argumentTypes: [],
                                                        arity: 0,
                                                        returnType: {
                                                                type: ValueType.MAP,
                                                                mult: SequenceMultiplicity.EXACTLY_ONE,
                                                        },
                                                })
                                        ),
                        },
                        {
                                key: createAtomicValue('permute', ValueType.XSSTRING),
                                value: () =>
                                        sequenceFactory.singleton(
                                                new FunctionValue({
                                                        value: permute,
                                                        isAnonymous: true,
                                                        localName: '',
                                                        namespaceURI: '',
                                                        argumentTypes: [
                                                                {
                                                                        type: ValueType.ITEM,
                                                                        mult: SequenceMultiplicity.ZERO_OR_MORE,
                                                                },
                                                        ],
                                                        arity: 1,
                                                        returnType: {
                                                                type: ValueType.ITEM,
                                                                mult: SequenceMultiplicity.ZERO_OR_MORE,
                                                        },
                                                })
                                        ),
                        },
                ])
        );
};

const declarations: BuiltinDeclarationType[] = [
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'abs',
                argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnAbs,
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'format-integer',
                argumentTypes: [
                        { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                        { type: ValueType.XSSTRING, mult: SequenceMultiplicity.EXACTLY_ONE },
                ],
                returnType: { type: ValueType.XSSTRING, mult: SequenceMultiplicity.EXACTLY_ONE },
                callFunction: fnFormatInteger,
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'ceiling',
                argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnCeiling,
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'floor',
                argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnFloor,
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'round',
                argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnRound.bind(null, false),
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'round',
                argumentTypes: [
                        { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                        { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.EXACTLY_ONE },
                ],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnRound.bind(null, false),
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'round-half-to-even',
                argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnRound.bind(null, true),
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'round-half-to-even',
                argumentTypes: [
                        { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                        { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.EXACTLY_ONE },
                ],
                returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnRound.bind(null, true),
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'number',
                argumentTypes: [
                        { type: ValueType.XSANYATOMICTYPE, mult: SequenceMultiplicity.ZERO_OR_ONE },
                ],
                returnType: { type: ValueType.XSDOUBLE, mult: SequenceMultiplicity.EXACTLY_ONE },
                callFunction: fnNumber,
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'number',
                argumentTypes: [],
                returnType: { type: ValueType.XSDOUBLE, mult: SequenceMultiplicity.EXACTLY_ONE },
                callFunction: (dynamicContext, executionParameters, staticContext) => {
                        const atomizedContextItem =
                                dynamicContext.contextItem &&
                                performFunctionConversion(
                                        { type: ValueType.XSANYATOMICTYPE, mult: SequenceMultiplicity.ZERO_OR_ONE },
                                        sequenceFactory.singleton(dynamicContext.contextItem),
                                        executionParameters,
                                        'fn:number',
                                        false
                                );
                        if (!atomizedContextItem) {
                                throw errXPDY0002('fn:number needs an atomizable context item.');
                        }
                        return fnNumber(
                                dynamicContext,
                                executionParameters,
                                staticContext,
                                atomizedContextItem
                        );
                },
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'random-number-generator',
                argumentTypes: [],
                returnType: { type: ValueType.MAP, mult: SequenceMultiplicity.EXACTLY_ONE },
                callFunction: fnRandomNumberGenerator,
        },

        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'random-number-generator',
                argumentTypes: [
                        {
                                type: ValueType.XSANYATOMICTYPE,
                                mult: SequenceMultiplicity.ZERO_OR_ONE,
                        },
                ],
                returnType: { type: ValueType.MAP, mult: SequenceMultiplicity.EXACTLY_ONE },
                callFunction: () => {
                        throw new Error('Not implemented: Specifying a seed is not supported');
                },
        },
];

export default {
        declarations,
        functions: {
                number: fnNumber,
                round: fnRound,
        },
};

1	import atomize from '../dataTypes/atomize';	9✔
2	import tryCastToType from '../dataTypes/casting/tryCastToType';	9✔
3	import castToType from '../dataTypes/castToType';	9✔
4	import createAtomicValue from '../dataTypes/createAtomicValue';	9✔
5	import FunctionValue from '../dataTypes/FunctionValue';	9✔
6	import type ISequence from '../dataTypes/ISequence';
7	import isSubtypeOf from '../dataTypes/isSubtypeOf';	9✔
8	import MapValue from '../dataTypes/MapValue';	9✔
9	import sequenceFactory from '../dataTypes/sequenceFactory';	9✔
10	import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
11	import type DynamicContext from '../DynamicContext';
12	import type ExecutionParameters from '../ExecutionParameters';
13	import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
14	import type StaticContext from '../StaticContext';
15	import { DONE_TOKEN, ready } from '../util/iterators';	9✔
16	import { errXPDY0002 } from '../XPathErrors';	9✔
17	import { performFunctionConversion } from './argumentHelper';	9✔
18	import type { BuiltinDeclarationType } from './builtInFunctions';
19	import type FunctionDefinitionType from './FunctionDefinitionType';
20
21	function createValidNumericType(type: ValueType, transformedValue: number) {
22	if (isSubtypeOf(type, ValueType.XSINTEGER)) {	6!
23	return createAtomicValue(transformedValue, ValueType.XSINTEGER);	6✔
24	}
25	if (isSubtypeOf(type, ValueType.XSFLOAT)) {	×
UNCOV 26	return createAtomicValue(transformedValue, ValueType.XSFLOAT);	×
27	}
28	if (isSubtypeOf(type, ValueType.XSDOUBLE)) {	×
UNCOV 29	return createAtomicValue(transformedValue, ValueType.XSDOUBLE);	×
30	}
31	// It must be a decimal, only four numeric types
UNCOV 32	return createAtomicValue(transformedValue, ValueType.XSDECIMAL);	×
33	}
34
35	const ROMAN_NUMBERS = [	9✔
36	{ symbol: 'M', decimal: 1000 },
37	{ symbol: 'CM', decimal: 900 },
38	{ symbol: 'D', decimal: 500 },
39	{ symbol: 'CD', decimal: 400 },
40	{ symbol: 'C', decimal: 100 },
41	{ symbol: 'XC', decimal: 90 },
42	{ symbol: 'L', decimal: 50 },
43	{ symbol: 'XL', decimal: 40 },
44	{ symbol: 'X', decimal: 10 },
45	{ symbol: 'IX', decimal: 9 },
46	{ symbol: 'V', decimal: 5 },
47	{ symbol: 'IV', decimal: 4 },
48	{ symbol: 'I', decimal: 1 },
49	];
50
51	function convertIntegerToRoman(integer: string, isLowerCase?: boolean) {
52	let int = parseInt(integer, 10);	15✔
53
54	const isNegative = int < 0;	15✔
55
56	int = Math.abs(int);	15✔
57
58	if (!int) {	15✔
59	return '-';	6✔
60	}
61
62	let romanString = ROMAN_NUMBERS.reduce((str, roman) => {	9✔
63	const q = Math.floor(int / roman.decimal);	117✔
64	int -= q * roman.decimal;	117✔
65	return str + roman.symbol.repeat(q);	117✔
66	}, '');
67
68	if (isLowerCase) {	9✔
69	romanString = romanString.toLowerCase();	6✔
70	}
71
72	if (isNegative) {	9✔
73	romanString = `-${romanString}`;	3✔
74	}
75
76	return romanString;	9✔
77	}
78
79	const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');	9✔
80
81	function convertIntegerToAlphabet(integer: string, isLowerCase?: boolean) {
82	let int = parseInt(integer, 10);	24✔
83
84	const isNegative = int < 0;	24✔
85
86	int = Math.abs(int);	24✔
87
88	if (!int) {	24✔
89	return '-';	6✔
90	}
91
92	let output = '';	18✔
93	let digit;
94
95	while (int > 0) {	18✔
96	digit = (int - 1) % ALPHABET.length;	27✔
97	output = ALPHABET[digit] + output;	27✔
98	int = ((int - digit) / ALPHABET.length) \| 0;	27✔
99	}
100
101	if (isLowerCase) {	18✔
102	output = output.toLowerCase();	12✔
103	}
104
105	if (isNegative) {	18✔
106	output = `-${output}`;	6✔
107	}
108
109	return output;	18✔
110	}
111
112	const fnAbs: FunctionDefinitionType = (	9✔
113	_dynamicContext,
114	_executionParameters,
115	_staticContext,
116	sequence
117	) => {
118	return sequence.map((onlyValue) =>	9✔
119	createValidNumericType(onlyValue.type, Math.abs(onlyValue.value))	6✔
120	);
121	};
122
123	const fnFormatInteger: FunctionDefinitionType = (	9✔
124	_dynamicContext,
125	_executionParameters,
126	_staticContext,
127	sequence,
128	pictureSequence
129	) => {
130	const sequenceValue = sequence.first();	54✔
131	const pictureValue = pictureSequence.first();	54✔
132
133	if (sequence.isEmpty()) {	54✔
134	return sequenceFactory.singleton(createAtomicValue('', ValueType.XSSTRING));	12✔
135	}
136
137	switch (pictureValue.value) {	42✔
138	case 'I': {
139	const romanString = convertIntegerToRoman(sequenceValue.value);	6✔
140	return sequenceFactory.singleton(createAtomicValue(romanString, ValueType.XSSTRING));	6✔
141	}
142	case 'i': {
143	const romanString = convertIntegerToRoman(sequenceValue.value, true);	9✔
144	return sequenceFactory.singleton(createAtomicValue(romanString, ValueType.XSSTRING));	9✔
145	}
146	case 'A': {
147	const alphabetString = convertIntegerToAlphabet(sequenceValue.value);	9✔
148	return sequenceFactory.singleton(createAtomicValue(alphabetString, ValueType.XSSTRING));	9✔
149	}
150	case 'a': {
151	const alphabetString = convertIntegerToAlphabet(sequenceValue.value, true);	15✔
152	return sequenceFactory.singleton(createAtomicValue(alphabetString, ValueType.XSSTRING));	15✔
153	}
154	default:
155	throw new Error(	3✔
156	`Picture: ${pictureValue.value} is not implemented yet. The supported picture strings are "A", "a", "I", and "i"`
157	);
158	}
159	};
160
161	const fnCeiling: FunctionDefinitionType = (	9✔
162	_dynamicContext,
163	_executionParameters,
164	_staticContext,
165	sequence
166	) => {
167	return sequence.map((onlyValue) =>	×
UNCOV 168	createValidNumericType(onlyValue.type, Math.ceil(onlyValue.value))	×
169	);
170	};
171
172	const fnFloor: FunctionDefinitionType = (	9✔
173	_dynamicContext,
174	_executionParameters,
175	_staticContext,
176	sequence
177	) => {
178	return sequence.map((onlyValue) =>	×
UNCOV 179	createValidNumericType(onlyValue.type, Math.floor(onlyValue.value))	×
180	);
181	};
182
183	function isHalf(value: number, scaling: number) {
184	return ((value * scaling) % 1) % 0.5 === 0;	39✔
185	}
186
187	function getNumberOfDecimalDigits(value: number) {
188	if (Math.floor(value) === value \|\| isNaN(value)) {	93✔
189	return 0;	57✔
190	}
191
192	const result = /\d+(?:\.(\d))?(?:[Ee](-)?(\d+))/.exec(`${value}`);	36✔
193	const decimals = result[1] ? result[1].length : 0;	36!
194
195	if (result[3]) {	36!
196	if (result[2]) {	×
UNCOV 197	return decimals + parseInt(result[3], 10);	×
198	}
199	const returnVal = decimals - parseInt(result[3], 10);	×
UNCOV 200	return returnVal < 0 ? 0 : returnVal;	×
201	}
202	return decimals;	36✔
203	}
204
205	function determineRoundedNumber(itemAsDecimal: number, halfToEven: boolean, scaling: number) {
206	if (halfToEven && isHalf(itemAsDecimal, scaling)) {	84✔
207	if (Math.floor(itemAsDecimal * scaling) % 2 === 0) {	24✔
208	return Math.floor(itemAsDecimal * scaling) / scaling;	15✔
209	}
210	return Math.ceil(itemAsDecimal * scaling) / scaling;	9✔
211	}
212	return Math.round(itemAsDecimal * scaling) / scaling;	60✔
213	}
214
215	function fnRound(
216	halfToEven: boolean,
217	_dynamicContext: DynamicContext,
218	_executionParameters: ExecutionParameters,
219	_staticContext: StaticContext,
220	sequence: ISequence,
221	precision: ISequence
222	): ISequence {
223	let done = false;	126✔
224	return sequenceFactory.create({	126✔
225	next: () => {
226	if (done) {	189✔
227	return DONE_TOKEN;	72✔
228	}
229	const firstValue = sequence.first();	117✔
230	if (!firstValue) {	117✔
231	// Empty sequence
232	done = true;	12✔
233	return DONE_TOKEN;	12✔
234	}
235
236	if (	105✔
237	(isSubtypeOf(firstValue.type, ValueType.XSFLOAT) \|\|	420✔
238	isSubtypeOf(firstValue.type, ValueType.XSDOUBLE)) &&
239	(firstValue.value === 0 \|\|
240	isNaN(firstValue.value as number) \|\|
241	firstValue.value === +Infinity \|\|
242	firstValue.value === -Infinity)
243	) {
244	done = true;	12✔
245	return ready(firstValue);	12✔
246	}
247	let scalingPrecision;
248	if (precision) {	93✔
249	const sp = precision.first();	21✔
250	scalingPrecision = sp.value;	21✔
251	} else {
252	scalingPrecision = 0;	72✔
253	}
254	done = true;	93✔
255
256	if (getNumberOfDecimalDigits(firstValue.value as number) < scalingPrecision) {	93✔
257	return ready(firstValue);	9✔
258	}
259
260	const originalType = [	84✔
261	ValueType.XSINTEGER,
262	ValueType.XSDECIMAL,
263	ValueType.XSDOUBLE,
264	ValueType.XSFLOAT,
265	].find((type: ValueType) => {
266	return isSubtypeOf(firstValue.type, type);	189✔
267	});
268	const itemAsDecimal = castToType(firstValue, ValueType.XSDECIMAL);	84✔
269	const scaling = Math.pow(10, scalingPrecision);	84✔
270	const roundedNumber = determineRoundedNumber(itemAsDecimal.value, halfToEven, scaling);	84✔
271	switch (originalType) {	84!
272	case ValueType.XSDECIMAL:
273	return ready(createAtomicValue(roundedNumber, ValueType.XSDECIMAL));	27✔
274	case ValueType.XSDOUBLE:
275	return ready(createAtomicValue(roundedNumber, ValueType.XSDOUBLE));	39✔
276	case ValueType.XSFLOAT:
UNCOV 277	return ready(createAtomicValue(roundedNumber, ValueType.XSFLOAT));	×
278	case ValueType.XSINTEGER:
279	return ready(createAtomicValue(roundedNumber, ValueType.XSINTEGER));	18✔
280	}
281	},
282	});
283	}
284
285	const fnNumber: FunctionDefinitionType = (	9✔
286	_dynamicContext,
287	executionParameters,
288	_staticContext,
289	sequence
290	) => {
291	return atomize(sequence, executionParameters).switchCases({	42✔
292	empty: () => sequenceFactory.singleton(createAtomicValue(NaN, ValueType.XSDOUBLE)),	9✔
293	singleton: () => {
294	const castResult = tryCastToType(sequence.first(), ValueType.XSDOUBLE);	30✔
295	if (castResult.successful) {	30✔
296	return sequenceFactory.singleton(castResult.value);	21✔
297	}
298	return sequenceFactory.singleton(createAtomicValue(NaN, ValueType.XSDOUBLE));	9✔
299	},
300	multiple: () => {
UNCOV 301	throw new Error('fn:number may only be called with zero or one values');	×
302	},
303	});
304	};
305
306	const permute: FunctionDefinitionType = (	9✔
307	_dynamicContext,
308	_executionParameters,
309	_staticContext,
310	sequence
311	) => {
312	if (sequence.isEmpty() \|\| sequence.isSingleton()) {	300!
UNCOV 313	return sequence;	×
314	}
315
316	const a = sequence.getAllValues();	300✔
317
318	// Use Durstenfeld shuffle to randomize the list
319	for (let i = a.length - 1; i > 1; i--) {	300✔
320	const j = Math.floor(Math.random() * (i + 1));	600✔
321	const t = a[j];	600✔
322	a[j] = a[i];	600✔
323	a[i] = t;	600✔
324	}
325
326	return sequenceFactory.create(a);	300✔
327	};
328
329	const fnRandomNumberGenerator: FunctionDefinitionType = (	9✔
330	_dynamicContext,
331	_executionParameters,
332	_staticContext,
333	_sequence
334	) => {
335	// Ignore the optional seed, as Math.random does not support a seed
336	return sequenceFactory.singleton(	1,206✔
337	new MapValue([
338	{
339	key: createAtomicValue('number', ValueType.XSSTRING),
340	value: () =>
341	sequenceFactory.singleton(createAtomicValue(Math.random(), ValueType.XSDOUBLE)),	600✔
342	},
343	{
344	key: createAtomicValue('next', ValueType.XSSTRING),
345	value: () =>
346	sequenceFactory.singleton(	303✔
347	new FunctionValue({
348	value: fnRandomNumberGenerator,
349	isAnonymous: true,
350	localName: '',
351	namespaceURI: '',
352	argumentTypes: [],
353	arity: 0,
354	returnType: {
355	type: ValueType.MAP,
356	mult: SequenceMultiplicity.EXACTLY_ONE,
357	},
358	})
359	),
360	},
361	{
362	key: createAtomicValue('permute', ValueType.XSSTRING),
363	value: () =>
364	sequenceFactory.singleton(	303✔
365	new FunctionValue({
366	value: permute,
367	isAnonymous: true,
368	localName: '',
369	namespaceURI: '',
370	argumentTypes: [
371	{
372	type: ValueType.ITEM,
373	mult: SequenceMultiplicity.ZERO_OR_MORE,
374	},
375	],
376	arity: 1,
377	returnType: {
378	type: ValueType.ITEM,
379	mult: SequenceMultiplicity.ZERO_OR_MORE,
380	},
381	})
382	),
383	},
384	])
385	);
386	};
387
388	const declarations: BuiltinDeclarationType[] = [	9✔
389	{
390	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
391	localName: 'abs',
392	argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
393	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
394	callFunction: fnAbs,
395	},
396
397	{
398	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
399	localName: 'format-integer',
400	argumentTypes: [
401	{ type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
402	{ type: ValueType.XSSTRING, mult: SequenceMultiplicity.EXACTLY_ONE },
403	],
404	returnType: { type: ValueType.XSSTRING, mult: SequenceMultiplicity.EXACTLY_ONE },
405	callFunction: fnFormatInteger,
406	},
407
408	{
409	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
410	localName: 'ceiling',
411	argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
412	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
413	callFunction: fnCeiling,
414	},
415
416	{
417	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
418	localName: 'floor',
419	argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
420	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
421	callFunction: fnFloor,
422	},
423
424	{
425	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
426	localName: 'round',
427	argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
428	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
429	callFunction: fnRound.bind(null, false),
430	},
431
432	{
433	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
434	localName: 'round',
435	argumentTypes: [
436	{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
437	{ type: ValueType.XSINTEGER, mult: SequenceMultiplicity.EXACTLY_ONE },
438	],
439	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
440	callFunction: fnRound.bind(null, false),
441	},
442
443	{
444	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
445	localName: 'round-half-to-even',
446	argumentTypes: [{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE }],
447	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
448	callFunction: fnRound.bind(null, true),
449	},
450
451	{
452	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
453	localName: 'round-half-to-even',
454	argumentTypes: [
455	{ type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
456	{ type: ValueType.XSINTEGER, mult: SequenceMultiplicity.EXACTLY_ONE },
457	],
458	returnType: { type: ValueType.XSNUMERIC, mult: SequenceMultiplicity.ZERO_OR_ONE },
459	callFunction: fnRound.bind(null, true),
460	},
461
462	{
463	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
464	localName: 'number',
465	argumentTypes: [
466	{ type: ValueType.XSANYATOMICTYPE, mult: SequenceMultiplicity.ZERO_OR_ONE },
467	],
468	returnType: { type: ValueType.XSDOUBLE, mult: SequenceMultiplicity.EXACTLY_ONE },
469	callFunction: fnNumber,
470	},
471
472	{
473	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
474	localName: 'number',
475	argumentTypes: [],
476	returnType: { type: ValueType.XSDOUBLE, mult: SequenceMultiplicity.EXACTLY_ONE },
477	callFunction: (dynamicContext, executionParameters, staticContext) => {
478	const atomizedContextItem =
479	dynamicContext.contextItem &&	9✔
480	performFunctionConversion(
481	{ type: ValueType.XSANYATOMICTYPE, mult: SequenceMultiplicity.ZERO_OR_ONE },
482	sequenceFactory.singleton(dynamicContext.contextItem),
483	executionParameters,
484	'fn:number',
485	false
486	);
487	if (!atomizedContextItem) {	9✔
488	throw errXPDY0002('fn:number needs an atomizable context item.');	3✔
489	}
490	return fnNumber(	6✔
491	dynamicContext,
492	executionParameters,
493	staticContext,
494	atomizedContextItem
495	);
496	},
497	},
498
499	{
500	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
501	localName: 'random-number-generator',
502	argumentTypes: [],
503	returnType: { type: ValueType.MAP, mult: SequenceMultiplicity.EXACTLY_ONE },
504	callFunction: fnRandomNumberGenerator,
505	},
506
507	{
508	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
509	localName: 'random-number-generator',
510	argumentTypes: [
511	{
512	type: ValueType.XSANYATOMICTYPE,
513	mult: SequenceMultiplicity.ZERO_OR_ONE,
514	},
515	],
516	returnType: { type: ValueType.MAP, mult: SequenceMultiplicity.EXACTLY_ONE },
517	callFunction: () => {
518	throw new Error('Not implemented: Specifying a seed is not supported');	3✔
519	},
520	},
521	];
522
523	export default {	9✔
524	declarations,
525	functions: {
526	number: fnNumber,
527	round: fnRound,
528	},
529	};

FontoXML / fontoxpath / 3320999782

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