2867988593

Build Type

github

Committed by GitHub

Commit Message

Merge c1af5cf3e into 4b81076fe

Pull Request Pull Request #520: Add fn:format-integer with supported pictures: "A", "a", "I" and "i"

Run Details

4765 of 5569 branches covered (85.56%)

Branch coverage included in aggregate %.

36 of 37 new or added lines in 1 file covered. (97.3%)

7 existing lines in 1 file now uncovered.

10238 of 10893 relevant lines covered (93.99%)

32981.82 hits per line

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

84.58

/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 { 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 fnAbs: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        return sequence.map((onlyValue) =>
                createValidNumericType(onlyValue.type, Math.abs(onlyValue.value))
        );
};

const convertIntegerToRoman = (integer: string, isLowerCase?: boolean) => {
        const romanNumbers = [
                { 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 },
        ];

        let int = parseInt(integer);
        let romanString = romanNumbers.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();
        }

        return romanString;
};

const convertIntegerToAlphabet = (integer: string, isLowerCase?: boolean) => {
        const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');

        let int = parseInt(integer);

        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();
        }

        return output;
};

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

FontoXML / fontoxpath / 2867988593

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