895627893

Build Type

github

Committed by GitHub

Commit Message

Merge 0c133a152 into 154cb0a16

Pull Request Pull Request #357: WIP: Type inference

Run Details

4378 of 4733 branches covered (92.5%)

Branch coverage included in aggregate %.

714 of 737 new or added lines in 104 files covered. (96.88%)

2 existing lines in 1 file now uncovered.

8734 of 8946 relevant lines covered (97.63%)

3492092.86 hits per line

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

84.48

/src/expressions/dataTypes/facets/facetsByDataType.ts

import { ValueType } from '../Value';
import decimalComparator from './comparators/decimalComparator';

// fractionDigits
function validateFractionDigits(value, fractionDigits) {
        const stringValue = value.toString();
        if (stringValue.indexOf('.') > -1 && fractionDigits === 0) {
                return false;
        }

        const regex = /^[-+]?0*([1-9]\d*)?(?:\.((?:\d*[1-9])*)0*)?$/;
        const match = regex.exec(stringValue);

        if (!match[2]) {
                return true;
        }

        return match[2].length <= fractionDigits;
}

// maxInclusive, maxExclusive, minInclusive, minExclusive
function createMaxInclusiveFacet(comperator) {
        return function validateMaxInclusive(value, maxInclusive) {
                return comperator(value, maxInclusive) < 1;
        };
}
function createMaxExclusiveFacet(comperator) {
        return function validateMaxExclusive(value, maxExclusive) {
                return comperator(value, maxExclusive) < 0;
        };
}
function createMinInclusiveFacet(comperator) {
        return function validateMinInclusive(value, minInclusive) {
                return comperator(value, minInclusive) > -1;
        };
}
function createMinExclusiveFacet(comperator) {
        return function validateMinExclusive(value, minExclusive) {
                return comperator(value, minExclusive) > 0;
        };
}

function validateExplicitTimeZone(value, option) {
        switch (option) {
                case 'required':
                        return /(Z)|([+-])([01]\d):([0-5]\d)$/.test(value.toString());
                case 'prohibited':
                        return !/(Z)|([+-])([01]\d):([0-5]\d)$/.test(value.toString());
                case 'optional':
                        return true;
        }
}

function getFacetByDataType(type: ValueType) {
        switch (type) {
                case ValueType.XSSTRING:
                case ValueType.XSBOOLEAN:
                case ValueType.XSFLOAT:
                case ValueType.XSDOUBLE:
                        return {};
                case ValueType.XSDECIMAL:
                        return {
                                fractionDigits: validateFractionDigits,
                                maxInclusive: createMaxInclusiveFacet(decimalComparator),
                                maxExclusive: createMaxExclusiveFacet(decimalComparator),
                                minInclusive: createMinInclusiveFacet(decimalComparator),
                                minExclusive: createMinExclusiveFacet(decimalComparator),
                        };
                case ValueType.XSDURATION:
                        return {};
                case ValueType.XSDATETIME:
                case ValueType.XSTIME:
                case ValueType.XSDATE:
                case ValueType.XSGYEARMONTH:
                case ValueType.XSGYEAR:
                case ValueType.XSGMONTHDAY:
                case ValueType.XSGDAY:
                case ValueType.XSGMONTH:
                        return { explicitTimezone: validateExplicitTimeZone };
                case ValueType.XSHEXBINARY:
                case ValueType.XSBASE64BINARY:
                case ValueType.XSANYURI:
                case ValueType.XSQNAME:
                case ValueType.XSNOTATION:
                        return {};
                default:
                        return null;
        }
}

export default {
        getFacetByDataType,
        list: {},
        union: {},
};

1	import { ValueType } from '../Value';
2	import decimalComparator from './comparators/decimalComparator';	15✔
3
4	// fractionDigits
5	function validateFractionDigits(value, fractionDigits) {
6	const stringValue = value.toString();	26,493✔
7	if (stringValue.indexOf('.') > -1 && fractionDigits === 0) {	26,493!
8	return false;	×
9	}
10
11	const regex = /^[-+]?0([1-9]\d)?(?:\.((?:\d[1-9]))0*)?$/;	26,493✔
12	const match = regex.exec(stringValue);	26,493✔
13
14	if (!match[2]) {	26,493!
15	return true;	26,493✔
16	}
17
18	return match[2].length <= fractionDigits;	×
19	}
20
21	// maxInclusive, maxExclusive, minInclusive, minExclusive
22	function createMaxInclusiveFacet(comperator) {
23	return function validateMaxInclusive(value, maxInclusive) {	15✔
24	return comperator(value, maxInclusive) < 1;	11,220✔
25	};
26	}
27	function createMaxExclusiveFacet(comperator) {
28	return function validateMaxExclusive(value, maxExclusive) {	15✔
UNCOV 29	return comperator(value, maxExclusive) < 0;	×
30	};
31	}
32	function createMinInclusiveFacet(comperator) {
33	return function validateMinInclusive(value, minInclusive) {	15✔
34	return comperator(value, minInclusive) > -1;	13,182✔
35	};
36	}
37	function createMinExclusiveFacet(comperator) {
38	return function validateMinExclusive(value, minExclusive) {	15✔
UNCOV 39	return comperator(value, minExclusive) > 0;	×
40	};
41	}
42
43	function validateExplicitTimeZone(value, option) {
44	switch (option) {	12,633✔
45	case 'required':	12,633!
46	return /(Z)\|([+-])([01]\d):([0-5]\d)$/.test(value.toString());	12✔
47	case 'prohibited':
48	return !/(Z)\|([+-])([01]\d):([0-5]\d)$/.test(value.toString());	×
49	case 'optional':
50	return true;	12,621✔
51	}
52	}
53
54	function getFacetByDataType(type: ValueType) {
55	switch (type) {	360✔
56	case ValueType.XSSTRING:	1,020✔
57	case ValueType.XSBOOLEAN:
58	case ValueType.XSFLOAT:
59	case ValueType.XSDOUBLE:
60	return {};	60✔
61	case ValueType.XSDECIMAL:
62	return {	15✔
63	fractionDigits: validateFractionDigits,
64	maxInclusive: createMaxInclusiveFacet(decimalComparator),
65	maxExclusive: createMaxExclusiveFacet(decimalComparator),
66	minInclusive: createMinInclusiveFacet(decimalComparator),
67	minExclusive: createMinExclusiveFacet(decimalComparator),
68	};
69	case ValueType.XSDURATION:
70	return {};	15✔
71	case ValueType.XSDATETIME:
72	case ValueType.XSTIME:
73	case ValueType.XSDATE:
74	case ValueType.XSGYEARMONTH:
75	case ValueType.XSGYEAR:
76	case ValueType.XSGMONTHDAY:
77	case ValueType.XSGDAY:
78	case ValueType.XSGMONTH:
79	return { explicitTimezone: validateExplicitTimeZone };	120✔
80	case ValueType.XSHEXBINARY:
81	case ValueType.XSBASE64BINARY:
82	case ValueType.XSANYURI:
83	case ValueType.XSQNAME:
84	case ValueType.XSNOTATION:
85	return {};	75✔
86	default:
87	return null;	75✔
88	}
89	}
90
91	export default {	15✔
92	getFacetByDataType,
93	list: {},
94	union: {},
95	};

FontoXML / fontoxpath / 895627893

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