1363666175

Build Type

github

Committed by GitHub

Commit Message

Merge 4dbd3aa9c into 604e7b22b

Pull Request Pull Request #431: Functions base + (local-)name support for JSCodegen

Run Details

4809 of 5171 branches covered (93.0%)

Branch coverage included in aggregate %.

58 of 60 new or added lines in 7 files covered. (96.67%)

4 existing lines in 2 files now uncovered.

9519 of 9758 relevant lines covered (97.55%)

5704761.09 hits per line

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

97.67

/src/jsCodegen/emitFunctionCallExpr.ts

import astHelper, { IAST } from '../parsing/astHelper';
import { CodeGenContext } from './CodeGenContext';
import {
        acceptAst,
        FunctionIdentifier,
        GeneratedCodeBaseType,
        getCompiledValueCode,
        IAstRejected,
        PartialCompilationResult,
        PartiallyCompiledAstAccepted,
        rejectAst,
} from './JavaScriptCompiledXPath';

const supportedFunctions: Record<
        string,
        (
                ast: IAST,
                identifier: FunctionIdentifier,
                staticContext: CodeGenContext
        ) => PartialCompilationResult
> = {
        'local-name': emitLocalNameFunction,
        name: emitNameFunction,
};

function emitArgument(
        ast: IAST,
        staticContext: CodeGenContext,
        identifier: FunctionIdentifier
): PartialCompilationResult {
        const baseExpr = staticContext.emitBaseExpr(ast, identifier, staticContext);

        if (!baseExpr.isAstAccepted) {
                return baseExpr;
        }

        return acceptAst(`${identifier}`, baseExpr.generatedCodeType, [baseExpr.code]);
}

export function emitFunctionCallExpr(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext
): PartialCompilationResult {
        const functionName = astHelper.getTextContent(astHelper.getFirstChild(ast, 'functionName'));

        if (supportedFunctions[functionName] !== undefined) {
                return supportedFunctions[functionName](ast, identifier, staticContext);
        }

        return rejectAst(`Unsupported function: ${functionName}`);
}

const contextItemCheck = `if (contextItem === undefined || contextItem === null) {
        throw new Error('XPDY0002: The function which was called depends on dynamic context, which is absent.');
}`;

function createLocalNameGetter(itemName: string) {
        return `(${itemName}.localName || ${itemName}.target || '')`;
}

function createNameGetter(itemName: string) {
        return `(((${itemName}.prefix || '').length !== 0 ? ${itemName}.prefix + ':' : '') 
                                                                + (${itemName}.localName || ${itemName}.target || ''))`;
}

function emitSpecificNameFunction(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext,
        nameGetterFunction: (itemName: string) => string,
        functionName: string
): PartialCompilationResult {
        const argsAst = astHelper.getFirstChild(ast, 'arguments');
        let code = '';
        if (argsAst.length === 1) {
                // No args
                code = `function ${identifier}(contextItem) {
                        ${contextItemCheck}
                        return ${nameGetterFunction('contextItem')};
                }`;
        } else if (argsAst.length === 2) {
                // One arg
                const innerAst = argsAst[1] as IAST;
                const emittedArg = emitArgument(innerAst, staticContext, 'arg');
                // Special handling if context item is passed in
                if (innerAst[0] === 'contextItemExpr') {
                        code = `function ${identifier}(contextItem) {
                                ${contextItemCheck}
                                return ${nameGetterFunction('contextItem')};
                        }`;
                } else {
                        if (!emittedArg.isAstAccepted) {
                                return emittedArg;
                        }

                        code = `function ${identifier}(contextItem) {
                                                                ${emittedArg.variables}
                                                                const value = ${getCompiledValueCode(emittedArg.code, emittedArg.generatedCodeType)[0]};
                                                                const childElement = value.next().value;
                                                                return (value.done ? "" : ${nameGetterFunction('childElement')});
                                                }`;
                }
        } else {
                // Two or more args
                return rejectAst(`Incorrect arg count for ${functionName} function`);
        }

        return acceptAst(code, {
                type: GeneratedCodeBaseType.Function,
                returnType: { type: GeneratedCodeBaseType.Value },
        });
}

function emitNameFunction(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext
): PartialCompilationResult {
        return emitSpecificNameFunction(ast, identifier, staticContext, createNameGetter, 'name()');
}

function emitLocalNameFunction(
        ast: IAST,
        identifier: FunctionIdentifier,
        staticContext: CodeGenContext
): PartialCompilationResult {
        return emitSpecificNameFunction(
                ast,
                identifier,
                staticContext,
                createLocalNameGetter,
                'local-name()'
        );
}

1	import astHelper, { IAST } from '../parsing/astHelper';	18✔
2	import { CodeGenContext } from './CodeGenContext';
3	import {	18✔
4	acceptAst,
5	FunctionIdentifier,
6	GeneratedCodeBaseType,
7	getCompiledValueCode,
8	IAstRejected,
9	PartialCompilationResult,
10	PartiallyCompiledAstAccepted,
11	rejectAst,
12	} from './JavaScriptCompiledXPath';
13
14	const supportedFunctions: Record<
15	string,
16	(
17	ast: IAST,
18	identifier: FunctionIdentifier,
19	staticContext: CodeGenContext
20	) => PartialCompilationResult
21	> = {	18✔
22	'local-name': emitLocalNameFunction,
23	name: emitNameFunction,
24	};
25
26	function emitArgument(
27	ast: IAST,
28	staticContext: CodeGenContext,
29	identifier: FunctionIdentifier
30	): PartialCompilationResult {
31	const baseExpr = staticContext.emitBaseExpr(ast, identifier, staticContext);	114✔
32
33	if (!baseExpr.isAstAccepted) {	114✔
34	return baseExpr;	102✔
35	}
36
37	return acceptAst(`${identifier}`, baseExpr.generatedCodeType, [baseExpr.code]);	12✔
38	}
39
40	export function emitFunctionCallExpr(	18✔
41	ast: IAST,
42	identifier: FunctionIdentifier,
43	staticContext: CodeGenContext
44	): PartialCompilationResult {
45	const functionName = astHelper.getTextContent(astHelper.getFirstChild(ast, 'functionName'));	63,618✔
46
47	if (supportedFunctions[functionName] !== undefined) {	63,618✔
48	return supportedFunctions[functionName](ast, identifier, staticContext);	126✔
49	}
50
51	return rejectAst(`Unsupported function: ${functionName}`);	63,492✔
52	}
53
54	const contextItemCheck = `if (contextItem === undefined \|\| contextItem === null) {	18✔
55	throw new Error('XPDY0002: The function which was called depends on dynamic context, which is absent.');
56	}`;
57
58	function createLocalNameGetter(itemName: string) {
NEW 59	return `(${itemName}.localName \|\| ${itemName}.target \|\| '')`;	×
60	}
61
62	function createNameGetter(itemName: string) {
63	return `(((${itemName}.prefix \|\| '').length !== 0 ? ${itemName}.prefix + ':' : '')	24✔
64	+ (${itemName}.localName \|\| ${itemName}.target \|\| ''))`;
65	}
66
67	function emitSpecificNameFunction(
68	ast: IAST,
69	identifier: FunctionIdentifier,
70	staticContext: CodeGenContext,
71	nameGetterFunction: (itemName: string) => string,
72	functionName: string
73	): PartialCompilationResult {
74	const argsAst = astHelper.getFirstChild(ast, 'arguments');	126✔
75	let code = '';	126✔
76	if (argsAst.length === 1) {	126✔
77	// No args
78	code = `function ${identifier}(contextItem) {	6✔
79	${contextItemCheck}
80	return ${nameGetterFunction('contextItem')};
81	}`;
82	} else if (argsAst.length === 2) {	120✔
83	// One arg
84	const innerAst = argsAst[1] as IAST;	114✔
85	const emittedArg = emitArgument(innerAst, staticContext, 'arg');	114✔
86	// Special handling if context item is passed in
87	if (innerAst[0] === 'contextItemExpr') {	114✔
88	code = `function ${identifier}(contextItem) {	6✔
89	${contextItemCheck}
90	return ${nameGetterFunction('contextItem')};
91	}`;
92	} else {
93	if (!emittedArg.isAstAccepted) {	108✔
94	return emittedArg;	96✔
95	}
96
97	code = `function ${identifier}(contextItem) {	12✔
98	${emittedArg.variables}
99	const value = ${getCompiledValueCode(emittedArg.code, emittedArg.generatedCodeType)[0]};
100	const childElement = value.next().value;
101	return (value.done ? "" : ${nameGetterFunction('childElement')});
102	}`;
103	}
104	} else {
105	// Two or more args
106	return rejectAst(`Incorrect arg count for ${functionName} function`);	6✔
107	}
108
109	return acceptAst(code, {	24✔
110	type: GeneratedCodeBaseType.Function,
111	returnType: { type: GeneratedCodeBaseType.Value },
112	});
113	}
114
115	function emitNameFunction(
116	ast: IAST,
117	identifier: FunctionIdentifier,
118	staticContext: CodeGenContext
119	): PartialCompilationResult {
120	return emitSpecificNameFunction(ast, identifier, staticContext, createNameGetter, 'name()');	90✔
121	}
122
123	function emitLocalNameFunction(
124	ast: IAST,
125	identifier: FunctionIdentifier,
126	staticContext: CodeGenContext
127	): PartialCompilationResult {
128	return emitSpecificNameFunction(	36✔
129	ast,
130	identifier,
131	staticContext,
132	createLocalNameGetter,
133	'local-name()'
134	);
135	}

FontoXML / fontoxpath / 1363666175

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