1363541838

Build Type

github

Committed by GitHub

Commit Message

Merge 16ba5779c into 604e7b22b

Pull Request Pull Request #424: Jscodegen unit test support

Run Details

4703 of 5066 branches covered (92.83%)

Branch coverage included in aggregate %.

136 of 137 new or added lines in 10 files covered. (99.27%)

3 existing lines in 1 file now uncovered.

9446 of 9685 relevant lines covered (97.53%)

5702801.97 hits per line

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

84.91

/src/expressions/dataTypes/Value.ts

// The actual type is type ValueValue = NodePointer | Function | string | number | boolean | QName | Duration | DateTime; but doing that gives us thousands of errors.
export type ValueValue = any;

export default class Value {
        constructor(public type: ValueType, readonly value: ValueValue) {}
}

/**
 * The value types. Every value in XPath is of one of these types
 * @private
 */
export const enum ValueType {
        XSBOOLEAN,
        XSSTRING,
        XSNUMERIC,
        XSDOUBLE,
        XSDECIMAL,
        XSINTEGER,
        XSFLOAT,
        XSDATE,
        XSTIME,
        XSDATETIME,
        XSDATETIMESTAMP,
        XSGYEARMONTH,
        XSGYEAR,
        XSGMONTHDAY,
        XSGMONTH,
        XSGDAY,
        XSYEARMONTHDURATION,
        XSDAYTIMEDURATION,
        XSDURATION,
        XSUNTYPEDATOMIC,
        XSANYURI,
        XSBASE64BINARY,
        XSHEXBINARY,
        XSQNAME,
        XSNCNAME,
        XSNAME,
        XSENTITY,
        XSNONPOSITIVEINTEGER,
        XSNEGATIVEINTEGER,
        XSPOSITIVEINTEGER,
        XSNONNEGATIVEINTEGER,
        XSLONG,
        XSINT,
        XSSHORT,
        XSBYTE,
        XSUNSIGNEDINT,
        XSUNSIGNEDLONG,
        XSUNSIGNEDBYTE,
        XSUNSIGNEDSHORT,
        XSERROR,
        XSENTITIES,
        XSIDREF,
        XSID,
        XSIDREFS,
        XSNOTATION,
        XSANYSIMPLETYPE,
        XSANYATOMICTYPE,
        ATTRIBUTE,
        XSNORMALIZEDSTRING,
        XSNMTOKENS,
        XSNMTOKEN,
        XSLANGUAGE,
        XSTOKEN,
        NODE,
        ELEMENT,
        DOCUMENTNODE,
        TEXT,
        PROCESSINGINSTRUCTION,
        COMMENT,
        ITEM,
        FUNCTION,
        MAP,
        ARRAY,
        NONE,
}

/**
 * Handles the occurances in the XPath specs.
 * Zero or one matches to '?';
 * One or more matches to '+';
 * Zero or more matches to '*'
 * @private
 */
export const enum SequenceMultiplicity {
        ZERO_OR_ONE = 0,
        ONE_OR_MORE = 1,
        ZERO_OR_MORE = 2,
        EXACTLY_ONE = 3,
}

/**
 * A seperate enum for the ellipsis function parameter
 * @private
 */
export const enum EllipsisType {
        ELLIPSIS = 4,
}

/**
 * The combined parameter type which is either a value type or an ellipsis type.
 * @private
 */
export type ParameterType = SequenceType | EllipsisType;

/**
 * The type of a sequence, it contains the ValueType and the multiplicity of the sequence.
 * @private
 */
export type SequenceType = {
        mult: SequenceMultiplicity;
        type: ValueType;
};

const typeToStringMap: Record<ValueType, string> = {
        [ValueType.XSBOOLEAN]: 'xs:boolean',
        [ValueType.XSSTRING]: 'xs:string',
        [ValueType.XSNUMERIC]: 'xs:numeric',
        [ValueType.XSDOUBLE]: 'xs:double',
        [ValueType.XSDECIMAL]: 'xs:decimal',
        [ValueType.XSINTEGER]: 'xs:integer',
        [ValueType.XSFLOAT]: 'xs:float',
        [ValueType.XSDATE]: 'xs:date',
        [ValueType.XSTIME]: 'xs:time',
        [ValueType.XSDATETIME]: 'xs:dateTime',
        [ValueType.XSDATETIMESTAMP]: 'xs:dateTimeStamp',
        [ValueType.XSGYEARMONTH]: 'xs:gYearMonth',
        [ValueType.XSGYEAR]: 'xs:gYear',
        [ValueType.XSGMONTHDAY]: 'xs:gMonthDay',
        [ValueType.XSGMONTH]: 'xs:gMonth',
        [ValueType.XSGDAY]: 'xs:gDay',
        [ValueType.XSYEARMONTHDURATION]: 'xs:yearMonthDuration',
        [ValueType.XSDAYTIMEDURATION]: 'xs:dayTimeDuration',
        [ValueType.XSDURATION]: 'xs:duration',
        [ValueType.XSUNTYPEDATOMIC]: 'xs:untypedAtomic',
        [ValueType.XSANYURI]: 'xs:anyURI',
        [ValueType.XSBASE64BINARY]: 'xs:base64Binary',
        [ValueType.XSHEXBINARY]: 'xs:hexBinary',
        [ValueType.XSQNAME]: 'xs:QName',
        [ValueType.XSNCNAME]: 'xs:NCName',
        [ValueType.XSNAME]: 'xs:Name',
        [ValueType.XSENTITY]: 'xs:ENTITY',
        [ValueType.XSNONPOSITIVEINTEGER]: 'xs:nonPositiveInteger',
        [ValueType.XSNEGATIVEINTEGER]: 'xs:negativeInteger',
        [ValueType.XSPOSITIVEINTEGER]: 'xs:positiveInteger',
        [ValueType.XSNONNEGATIVEINTEGER]: 'xs:nonNegativeInteger',
        [ValueType.XSLONG]: 'xs:long',
        [ValueType.XSINT]: 'xs:int',
        [ValueType.XSSHORT]: 'xs:short',
        [ValueType.XSBYTE]: 'xs:byte',
        [ValueType.XSUNSIGNEDINT]: 'xs:unsignedInt',
        [ValueType.XSUNSIGNEDLONG]: 'xs:unsignedLong',
        [ValueType.XSUNSIGNEDBYTE]: 'xs:unsignedByte',
        [ValueType.XSUNSIGNEDSHORT]: 'xs:unsignedShort',
        [ValueType.XSERROR]: 'xs:error',
        [ValueType.XSENTITIES]: 'xs:ENTITIES',
        [ValueType.XSIDREF]: 'xs:IDREF',
        [ValueType.XSID]: 'xs:ID',
        [ValueType.XSIDREFS]: 'xs:IDFREFS',
        [ValueType.XSNOTATION]: 'xs:NOTATION',
        [ValueType.XSANYSIMPLETYPE]: 'xs:anySimpleType',
        [ValueType.XSANYATOMICTYPE]: 'xs:anyAtomicType',
        [ValueType.ATTRIBUTE]: 'attribute()',
        [ValueType.XSNORMALIZEDSTRING]: 'xs:normalizedString',
        [ValueType.XSNMTOKENS]: 'xs:NMTOKENS',
        [ValueType.XSNMTOKEN]: 'xs:NMTOKEN',
        [ValueType.XSLANGUAGE]: 'xs:language',
        [ValueType.XSTOKEN]: 'xs:token',
        [ValueType.NODE]: 'node()',
        [ValueType.ELEMENT]: 'element()',
        [ValueType.DOCUMENTNODE]: 'document-node()',
        [ValueType.TEXT]: 'text()',
        [ValueType.PROCESSINGINSTRUCTION]: 'processing-instruction()',
        [ValueType.COMMENT]: 'comment()',
        [ValueType.ITEM]: 'item()',
        [ValueType.FUNCTION]: 'function(*)',
        [ValueType.MAP]: 'map(*)',
        [ValueType.ARRAY]: 'array(*)',
        [ValueType.NONE]: 'none',
};

const stringToValueTypeMap: { [key: string]: ValueType } = {
        'xs:boolean': ValueType.XSBOOLEAN,
        'xs:string': ValueType.XSSTRING,
        'xs:numeric': ValueType.XSNUMERIC,
        'xs:double': ValueType.XSDOUBLE,
        'xs:decimal': ValueType.XSDECIMAL,
        'xs:integer': ValueType.XSINTEGER,
        'xs:float': ValueType.XSFLOAT,
        'xs:date': ValueType.XSDATE,
        'xs:time': ValueType.XSTIME,
        'xs:dateTime': ValueType.XSDATETIME,
        'xs:dateTimeStamp': ValueType.XSDATETIMESTAMP,
        'xs:gYearMonth': ValueType.XSGYEARMONTH,
        'xs:gYear': ValueType.XSGYEAR,
        'xs:gMonthDay': ValueType.XSGMONTHDAY,
        'xs:gMonth': ValueType.XSGMONTH,
        'xs:gDay': ValueType.XSGDAY,
        'xs:yearMonthDuration': ValueType.XSYEARMONTHDURATION,
        'xs:dayTimeDuration': ValueType.XSDAYTIMEDURATION,
        'xs:duration': ValueType.XSDURATION,
        'xs:untypedAtomic': ValueType.XSUNTYPEDATOMIC,
        'xs:anyURI': ValueType.XSANYURI,
        'xs:base64Binary': ValueType.XSBASE64BINARY,
        'xs:hexBinary': ValueType.XSHEXBINARY,
        'xs:QName': ValueType.XSQNAME,
        'xs:NCName': ValueType.XSNCNAME,
        'xs:Name': ValueType.XSNAME,
        'xs:ENTITY': ValueType.XSENTITY,
        'xs:nonPositiveInteger': ValueType.XSNONPOSITIVEINTEGER,
        'xs:negativeInteger': ValueType.XSNEGATIVEINTEGER,
        'xs:positiveInteger': ValueType.XSPOSITIVEINTEGER,
        'xs:nonNegativeInteger': ValueType.XSNONNEGATIVEINTEGER,
        'xs:long': ValueType.XSLONG,
        'xs:int': ValueType.XSINT,
        'xs:short': ValueType.XSSHORT,
        'xs:byte': ValueType.XSBYTE,
        'xs:unsignedInt': ValueType.XSUNSIGNEDINT,
        'xs:unsignedLong': ValueType.XSUNSIGNEDLONG,
        'xs:unsignedByte': ValueType.XSUNSIGNEDBYTE,
        'xs:unsignedShort': ValueType.XSUNSIGNEDSHORT,
        'xs:error': ValueType.XSERROR,
        'xs:ENTITIES': ValueType.XSENTITIES,
        'xs:IDREF': ValueType.XSIDREF,
        'xs:ID': ValueType.XSID,
        'xs:IDREFS': ValueType.XSIDREFS,
        'xs:NOTATION': ValueType.XSNOTATION,
        'xs:anySimpleType': ValueType.XSANYSIMPLETYPE,
        'xs:anyAtomicType': ValueType.XSANYATOMICTYPE,
        'attribute()': ValueType.ATTRIBUTE,
        'xs:normalizedString': ValueType.XSNORMALIZEDSTRING,
        'xs:NMTOKENS': ValueType.XSNMTOKENS,
        'xs:NMTOKEN': ValueType.XSNMTOKEN,
        'xs:language': ValueType.XSLANGUAGE,
        'xs:token': ValueType.XSTOKEN,
        'node()': ValueType.NODE,
        'element()': ValueType.ELEMENT,
        'document-node()': ValueType.DOCUMENTNODE,
        'text()': ValueType.TEXT,
        'processing-instruction()': ValueType.PROCESSINGINSTRUCTION,
        'comment()': ValueType.COMMENT,
        'item()': ValueType.ITEM,
        'function(*)': ValueType.FUNCTION,
        'map(*)': ValueType.MAP,
        'array(*)': ValueType.ARRAY,
};

/**
 * Creates a string value from a base type, generally follows the 'xs:type' notation, where
 * xs stands for XML Schema
 * @param input The base type to get the string of
 * @returns A string corresponding to that base type.
 */
export function valueTypeToString(input: ValueType): string {
        return typeToStringMap[input];
}

/**
 * Converts a ValueType to the correct string representation
 *
 * @param input the ValueType
 * @returns the correct string representation of the type
 */
export function sequenceTypeToString(input: SequenceType): string {
        if (input.mult === SequenceMultiplicity.ZERO_OR_MORE) {
                return valueTypeToString(input.type) + '*';
        }
        if (input.mult === SequenceMultiplicity.ONE_OR_MORE) {
                return valueTypeToString(input.type) + '+';
        }
        if (input.mult === SequenceMultiplicity.ZERO_OR_ONE) {
                return valueTypeToString(input.type) + '?';
        }

        return valueTypeToString(input.type);
}

export function stringToValueType(input: string): ValueType {
        if (!input.startsWith('xs:') && input.indexOf(':') >= 0) {
                throw new Error(`XPST0081: Invalid prefix for input ${input}`);
        }

        const type = stringToValueTypeMap[input];

        if (type === undefined) {
                throw new Error(`XPST0051: The type "${input}" could not be found`);
        }

        return type;
}

export function stringToSequenceType(input: string): SequenceType {
        switch (input[input.length - 1]) {
                case '*':
                        return {
                                type: stringToValueType(input.substr(0, input.length - 1)),
                                mult: SequenceMultiplicity.ZERO_OR_MORE,
                        };
                case '?':
                        return {
                                type: stringToValueType(input.substr(0, input.length - 1)),
                                mult: SequenceMultiplicity.ZERO_OR_ONE,
                        };
                case '+':
                        return {
                                type: stringToValueType(input.substr(0, input.length - 1)),
                                mult: SequenceMultiplicity.ONE_OR_MORE,
                        };
                default:
                        return {
                                type: stringToValueType(input),
                                mult: SequenceMultiplicity.EXACTLY_ONE,
                        };
        }
}

export function stringToSequenceMultiplicity(input: string): SequenceMultiplicity {
        switch (input) {
                case '*':
                        return SequenceMultiplicity.ZERO_OR_MORE;
                case '?':
                        return SequenceMultiplicity.ZERO_OR_ONE;
                case '+':
                        return SequenceMultiplicity.ONE_OR_MORE;
                default:
                        return SequenceMultiplicity.EXACTLY_ONE;
        }
}

1	// The actual type is type ValueValue = NodePointer \| Function \| string \| number \| boolean \| QName \| Duration \| DateTime; but doing that gives us thousands of errors.
2	export type ValueValue = any;
3
4	export default class Value {	18✔
5	constructor(public type: ValueType, readonly value: ValueValue) {}	1,272,942✔
6	}
7
8	/**
9	* The value types. Every value in XPath is of one of these types
10	* @private
11	*/
12	export const enum ValueType {
13	XSBOOLEAN,
14	XSSTRING,
15	XSNUMERIC,
16	XSDOUBLE,
17	XSDECIMAL,
18	XSINTEGER,
19	XSFLOAT,
20	XSDATE,
21	XSTIME,
22	XSDATETIME,
23	XSDATETIMESTAMP,
24	XSGYEARMONTH,
25	XSGYEAR,
26	XSGMONTHDAY,
27	XSGMONTH,
28	XSGDAY,
29	XSYEARMONTHDURATION,
30	XSDAYTIMEDURATION,
31	XSDURATION,
32	XSUNTYPEDATOMIC,
33	XSANYURI,
34	XSBASE64BINARY,
35	XSHEXBINARY,
36	XSQNAME,
37	XSNCNAME,
38	XSNAME,
39	XSENTITY,
40	XSNONPOSITIVEINTEGER,
41	XSNEGATIVEINTEGER,
42	XSPOSITIVEINTEGER,
43	XSNONNEGATIVEINTEGER,
44	XSLONG,
45	XSINT,
46	XSSHORT,
47	XSBYTE,
48	XSUNSIGNEDINT,
49	XSUNSIGNEDLONG,
50	XSUNSIGNEDBYTE,
51	XSUNSIGNEDSHORT,
52	XSERROR,
53	XSENTITIES,
54	XSIDREF,
55	XSID,
56	XSIDREFS,
57	XSNOTATION,
58	XSANYSIMPLETYPE,
59	XSANYATOMICTYPE,
60	ATTRIBUTE,
61	XSNORMALIZEDSTRING,
62	XSNMTOKENS,
63	XSNMTOKEN,
64	XSLANGUAGE,
65	XSTOKEN,
66	NODE,
67	ELEMENT,
68	DOCUMENTNODE,
69	TEXT,
70	PROCESSINGINSTRUCTION,
71	COMMENT,
72	ITEM,
73	FUNCTION,
74	MAP,
75	ARRAY,
76	NONE,
77	}
78
79	/**
80	* Handles the occurances in the XPath specs.
81	* Zero or one matches to '?';
82	* One or more matches to '+';
83	* Zero or more matches to '*'
84	* @private
85	*/
86	export const enum SequenceMultiplicity {
87	ZERO_OR_ONE = 0,
88	ONE_OR_MORE = 1,
89	ZERO_OR_MORE = 2,
90	EXACTLY_ONE = 3,
91	}
92
93	/**
94	* A seperate enum for the ellipsis function parameter
95	* @private
96	*/
97	export const enum EllipsisType {
98	ELLIPSIS = 4,
99	}
100
101	/**
102	* The combined parameter type which is either a value type or an ellipsis type.
103	* @private
104	*/
105	export type ParameterType = SequenceType \| EllipsisType;
106
107	/**
108	* The type of a sequence, it contains the ValueType and the multiplicity of the sequence.
109	* @private
110	*/
111	export type SequenceType = {
112	mult: SequenceMultiplicity;
113	type: ValueType;
114	};
115
116	const typeToStringMap: Record<ValueType, string> = {	18✔
117	[ValueType.XSBOOLEAN]: 'xs:boolean',
118	[ValueType.XSSTRING]: 'xs:string',
119	[ValueType.XSNUMERIC]: 'xs:numeric',
120	[ValueType.XSDOUBLE]: 'xs:double',
121	[ValueType.XSDECIMAL]: 'xs:decimal',
122	[ValueType.XSINTEGER]: 'xs:integer',
123	[ValueType.XSFLOAT]: 'xs:float',
124	[ValueType.XSDATE]: 'xs:date',
125	[ValueType.XSTIME]: 'xs:time',
126	[ValueType.XSDATETIME]: 'xs:dateTime',
127	[ValueType.XSDATETIMESTAMP]: 'xs:dateTimeStamp',
128	[ValueType.XSGYEARMONTH]: 'xs:gYearMonth',
129	[ValueType.XSGYEAR]: 'xs:gYear',
130	[ValueType.XSGMONTHDAY]: 'xs:gMonthDay',
131	[ValueType.XSGMONTH]: 'xs:gMonth',
132	[ValueType.XSGDAY]: 'xs:gDay',
133	[ValueType.XSYEARMONTHDURATION]: 'xs:yearMonthDuration',
134	[ValueType.XSDAYTIMEDURATION]: 'xs:dayTimeDuration',
135	[ValueType.XSDURATION]: 'xs:duration',
136	[ValueType.XSUNTYPEDATOMIC]: 'xs:untypedAtomic',
137	[ValueType.XSANYURI]: 'xs:anyURI',
138	[ValueType.XSBASE64BINARY]: 'xs:base64Binary',
139	[ValueType.XSHEXBINARY]: 'xs:hexBinary',
140	[ValueType.XSQNAME]: 'xs:QName',
141	[ValueType.XSNCNAME]: 'xs:NCName',
142	[ValueType.XSNAME]: 'xs:Name',
143	[ValueType.XSENTITY]: 'xs:ENTITY',
144	[ValueType.XSNONPOSITIVEINTEGER]: 'xs:nonPositiveInteger',
145	[ValueType.XSNEGATIVEINTEGER]: 'xs:negativeInteger',
146	[ValueType.XSPOSITIVEINTEGER]: 'xs:positiveInteger',
147	[ValueType.XSNONNEGATIVEINTEGER]: 'xs:nonNegativeInteger',
148	[ValueType.XSLONG]: 'xs:long',
149	[ValueType.XSINT]: 'xs:int',
150	[ValueType.XSSHORT]: 'xs:short',
151	[ValueType.XSBYTE]: 'xs:byte',
152	[ValueType.XSUNSIGNEDINT]: 'xs:unsignedInt',
153	[ValueType.XSUNSIGNEDLONG]: 'xs:unsignedLong',
154	[ValueType.XSUNSIGNEDBYTE]: 'xs:unsignedByte',
155	[ValueType.XSUNSIGNEDSHORT]: 'xs:unsignedShort',
156	[ValueType.XSERROR]: 'xs:error',
157	[ValueType.XSENTITIES]: 'xs:ENTITIES',
158	[ValueType.XSIDREF]: 'xs:IDREF',
159	[ValueType.XSID]: 'xs:ID',
160	[ValueType.XSIDREFS]: 'xs:IDFREFS',
161	[ValueType.XSNOTATION]: 'xs:NOTATION',
162	[ValueType.XSANYSIMPLETYPE]: 'xs:anySimpleType',
163	[ValueType.XSANYATOMICTYPE]: 'xs:anyAtomicType',
164	[ValueType.ATTRIBUTE]: 'attribute()',
165	[ValueType.XSNORMALIZEDSTRING]: 'xs:normalizedString',
166	[ValueType.XSNMTOKENS]: 'xs:NMTOKENS',
167	[ValueType.XSNMTOKEN]: 'xs:NMTOKEN',
168	[ValueType.XSLANGUAGE]: 'xs:language',
169	[ValueType.XSTOKEN]: 'xs:token',
170	[ValueType.NODE]: 'node()',
171	[ValueType.ELEMENT]: 'element()',
172	[ValueType.DOCUMENTNODE]: 'document-node()',
173	[ValueType.TEXT]: 'text()',
174	[ValueType.PROCESSINGINSTRUCTION]: 'processing-instruction()',
175	[ValueType.COMMENT]: 'comment()',
176	[ValueType.ITEM]: 'item()',
177	[ValueType.FUNCTION]: 'function(*)',
178	[ValueType.MAP]: 'map(*)',
179	[ValueType.ARRAY]: 'array(*)',
180	[ValueType.NONE]: 'none',
181	};
182
183	const stringToValueTypeMap: { [key: string]: ValueType } = {	18✔
184	'xs:boolean': ValueType.XSBOOLEAN,
185	'xs:string': ValueType.XSSTRING,
186	'xs:numeric': ValueType.XSNUMERIC,
187	'xs:double': ValueType.XSDOUBLE,
188	'xs:decimal': ValueType.XSDECIMAL,
189	'xs:integer': ValueType.XSINTEGER,
190	'xs:float': ValueType.XSFLOAT,
191	'xs:date': ValueType.XSDATE,
192	'xs:time': ValueType.XSTIME,
193	'xs:dateTime': ValueType.XSDATETIME,
194	'xs:dateTimeStamp': ValueType.XSDATETIMESTAMP,
195	'xs:gYearMonth': ValueType.XSGYEARMONTH,
196	'xs:gYear': ValueType.XSGYEAR,
197	'xs:gMonthDay': ValueType.XSGMONTHDAY,
198	'xs:gMonth': ValueType.XSGMONTH,
199	'xs:gDay': ValueType.XSGDAY,
200	'xs:yearMonthDuration': ValueType.XSYEARMONTHDURATION,
201	'xs:dayTimeDuration': ValueType.XSDAYTIMEDURATION,
202	'xs:duration': ValueType.XSDURATION,
203	'xs:untypedAtomic': ValueType.XSUNTYPEDATOMIC,
204	'xs:anyURI': ValueType.XSANYURI,
205	'xs:base64Binary': ValueType.XSBASE64BINARY,
206	'xs:hexBinary': ValueType.XSHEXBINARY,
207	'xs:QName': ValueType.XSQNAME,
208	'xs:NCName': ValueType.XSNCNAME,
209	'xs:Name': ValueType.XSNAME,
210	'xs:ENTITY': ValueType.XSENTITY,
211	'xs:nonPositiveInteger': ValueType.XSNONPOSITIVEINTEGER,
212	'xs:negativeInteger': ValueType.XSNEGATIVEINTEGER,
213	'xs:positiveInteger': ValueType.XSPOSITIVEINTEGER,
214	'xs:nonNegativeInteger': ValueType.XSNONNEGATIVEINTEGER,
215	'xs:long': ValueType.XSLONG,
216	'xs:int': ValueType.XSINT,
217	'xs:short': ValueType.XSSHORT,
218	'xs:byte': ValueType.XSBYTE,
219	'xs:unsignedInt': ValueType.XSUNSIGNEDINT,
220	'xs:unsignedLong': ValueType.XSUNSIGNEDLONG,
221	'xs:unsignedByte': ValueType.XSUNSIGNEDBYTE,
222	'xs:unsignedShort': ValueType.XSUNSIGNEDSHORT,
223	'xs:error': ValueType.XSERROR,
224	'xs:ENTITIES': ValueType.XSENTITIES,
225	'xs:IDREF': ValueType.XSIDREF,
226	'xs:ID': ValueType.XSID,
227	'xs:IDREFS': ValueType.XSIDREFS,
228	'xs:NOTATION': ValueType.XSNOTATION,
229	'xs:anySimpleType': ValueType.XSANYSIMPLETYPE,
230	'xs:anyAtomicType': ValueType.XSANYATOMICTYPE,
231	'attribute()': ValueType.ATTRIBUTE,
232	'xs:normalizedString': ValueType.XSNORMALIZEDSTRING,
233	'xs:NMTOKENS': ValueType.XSNMTOKENS,
234	'xs:NMTOKEN': ValueType.XSNMTOKEN,
235	'xs:language': ValueType.XSLANGUAGE,
236	'xs:token': ValueType.XSTOKEN,
237	'node()': ValueType.NODE,
238	'element()': ValueType.ELEMENT,
239	'document-node()': ValueType.DOCUMENTNODE,
240	'text()': ValueType.TEXT,
241	'processing-instruction()': ValueType.PROCESSINGINSTRUCTION,
242	'comment()': ValueType.COMMENT,
243	'item()': ValueType.ITEM,
244	'function(*)': ValueType.FUNCTION,
245	'map(*)': ValueType.MAP,
246	'array(*)': ValueType.ARRAY,
247	};
248
249	/**
250	* Creates a string value from a base type, generally follows the 'xs:type' notation, where
251	* xs stands for XML Schema
252	* @param input The base type to get the string of
253	* @returns A string corresponding to that base type.
254	*/
255	export function valueTypeToString(input: ValueType): string {	18✔
256	return typeToStringMap[input];	17,187✔
257	}
258
259	/**
260	* Converts a ValueType to the correct string representation
261	*
262	* @param input the ValueType
263	* @returns the correct string representation of the type
264	*/
265	export function sequenceTypeToString(input: SequenceType): string {	18✔
266	if (input.mult === SequenceMultiplicity.ZERO_OR_MORE) {	8,796✔
267	return valueTypeToString(input.type) + '*';	1,035✔
268	}
269	if (input.mult === SequenceMultiplicity.ONE_OR_MORE) {	7,761!
UNCOV 270	return valueTypeToString(input.type) + '+';	×
271	}
272	if (input.mult === SequenceMultiplicity.ZERO_OR_ONE) {	7,761✔
273	return valueTypeToString(input.type) + '?';	5,211✔
274	}
275
276	return valueTypeToString(input.type);	2,550✔
277	}
278
279	export function stringToValueType(input: string): ValueType {	18✔
280	if (!input.startsWith('xs:') && input.indexOf(':') >= 0) {	33,900,714✔
281	throw new Error(`XPST0081: Invalid prefix for input ${input}`);	27✔
282	}
283
284	const type = stringToValueTypeMap[input];	33,900,687✔
285
286	if (type === undefined) {	33,900,687✔
287	throw new Error(`XPST0051: The type "${input}" could not be found`);	24✔
288	}
289
290	return type;	33,900,663✔
291	}
292
293	export function stringToSequenceType(input: string): SequenceType {	18✔
294	switch (input[input.length - 1]) {	222✔
295	case '*':	222✔
296	return {	21✔
297	type: stringToValueType(input.substr(0, input.length - 1)),
298	mult: SequenceMultiplicity.ZERO_OR_MORE,
299	};
300	case '?':
301	return {	24✔
302	type: stringToValueType(input.substr(0, input.length - 1)),
303	mult: SequenceMultiplicity.ZERO_OR_ONE,
304	};
305	case '+':
306	return {	3✔
307	type: stringToValueType(input.substr(0, input.length - 1)),
308	mult: SequenceMultiplicity.ONE_OR_MORE,
309	};
310	default:
311	return {	174✔
312	type: stringToValueType(input),
313	mult: SequenceMultiplicity.EXACTLY_ONE,
314	};
315	}
316	}
317
318	export function stringToSequenceMultiplicity(input: string): SequenceMultiplicity {	18✔
319	switch (input) {	54✔
320	case '*':	54!
321	return SequenceMultiplicity.ZERO_OR_MORE;	×
322	case '?':
UNCOV 323	return SequenceMultiplicity.ZERO_OR_ONE;	×
324	case '+':
325	return SequenceMultiplicity.ONE_OR_MORE;	54✔
326	default:
UNCOV 327	return SequenceMultiplicity.EXACTLY_ONE;	×
328	}
329	}

FontoXML / fontoxpath / 1363541838

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