12302726031

Committed 12 Dec 2024 06:40PM UTC coverage: 84.055% (-0.6%) from 84.691%

Build # 12302726031

Build Type

Pull #4806

github

Committed by

web-flow

Commit Message

Merge 87fc178f5 into 3b8fcab21

Pull Request Pull Request #4806: feat: Support Sso for SharePoint bot ACEs

Run Details

8149 of 10862 branches covered (75.02%)

Branch coverage included in aggregate %.

7 of 57 new or added lines in 5 files covered. (12.28%)

153 existing lines in 14 files now uncovered.

20438 of 23148 relevant lines covered (88.29%)

3457.65 hits per line

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

3.23

/libraries/botbuilder-lg/src/extractor.ts

/**
 * @module botbuilder-lg
 */
/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License.
 */
import { AbstractParseTreeVisitor, TerminalNode } from 'antlr4ts/tree';
import keyBy from 'lodash/keyBy';
import { LGTemplateParserVisitor } from './generated/LGTemplateParserVisitor';
import { Template } from './template';

import {
    IfConditionContext,
    IfConditionRuleContext,
    IfElseBodyContext,
    NormalTemplateBodyContext,
    StructuredBodyContext,
    SwitchCaseBodyContext,
    SwitchCaseRuleContext,
    SwitchCaseStatContext,
} from './generated/LGTemplateParser';

/**
 * Lg template extracter.
 */
export class Extractor
    extends AbstractParseTreeVisitor<Map<string, string[]>>
    implements LGTemplateParserVisitor<Map<string, string[]>>
{
    readonly templates: Template[];

    readonly templateMap: Record<string, Template>;

    /**
     * Creates a new instance of the [Extractor](xref:botbuilder-lg.Extractor) class.
     *
     * @param templates Template list.
     */
    constructor(templates: Template[]) {
        super();
        this.templates = templates;
        this.templateMap = keyBy(templates, (t: Template): string => t.name);
    }

    /**
     * Extracts the templates and returns a map with their names and bodies.
     *
     * @returns Map object with template names and bodies.
     */
    extract(): Map<string, string[] | Map<string, string[]>>[] {
        const result: Map<string, string[] | Map<string, string[]>>[] = [];
        this.templates.forEach((template: Template) => {
            const templateResult = new Map<string, string[] | Map<string, string[]>>();
            const templateName: string = template.name;
            const templateBodies = this.visit(template.templateBodyParseTree);
            let isNormalTemplate = true;
            templateBodies.forEach(
                (templateBody) => (isNormalTemplate = isNormalTemplate && templateBody === undefined),
            );

            if (isNormalTemplate) {
                const templates: string[] = [];
                for (const templateBody of templateBodies) {
                    templates.push(templateBody[0]);
                }
                templateResult.set(templateName, templates);
            } else {
                templateResult.set(templateName, templateBodies);
            }

            result.push(templateResult);
        });

        return result;
    }

    /**
     * Visit a parse tree produced by LGTemplateParser.normalTemplateBody.
     *
     * @param context The parse tree.
     * @returns The result of visiting the normal template body.
     */
    visitNormalTemplateBody(context: NormalTemplateBodyContext): Map<string, string[]> {
        const result = new Map<string, string[]>();
        for (const templateStr of context.templateString()) {
            result.set(templateStr.normalTemplateString().text, undefined);
        }

        return result;
    }

    /**
     * Visit a parse tree produced by the structuredBody labeled alternative in LGTemplateParser.body.
     *
     * @param context The parse tree.
     * @returns The result of visiting the structured body.
     */
    visitStructuredBody(context: StructuredBodyContext): Map<string, string[]> {
        const result = new Map<string, string[]>();
        const lineStart = '    ';
        const structName = context.structuredTemplateBody().structuredBodyNameLine().text;
        let fullStr = structName + '\n';
        context
            .structuredTemplateBody()
            .structuredBodyContentLine()
            .forEach((line): string => (fullStr += lineStart + line.text + '\n'));
        fullStr += context.structuredTemplateBody().structuredBodyEndLine().text;

        result.set(fullStr, undefined);
        return result;
    }

    /**
     * Visit a parse tree produced by the ifElseBody labeled alternative in LGTemplateParser.body.
     *
     * @param context The parse tree.
     * @returns The result of visiting the if else body.
     */
    visitIfElseBody(context: IfElseBodyContext): Map<string, string[]> {
        const result = new Map<string, string[]>();
        const ifRules: IfConditionRuleContext[] = context.ifElseTemplateBody().ifConditionRule();
        for (const ifRule of ifRules) {
            const expressions = ifRule.ifCondition().expression();
            const conditionNode: IfConditionContext = ifRule.ifCondition();
            const ifExpr: boolean = conditionNode.IF() !== undefined;
            const elseIfExpr: boolean = conditionNode.ELSEIF() !== undefined;

            const node: TerminalNode = ifExpr
                ? conditionNode.IF()
                : elseIfExpr
                  ? conditionNode.ELSEIF()
                  : conditionNode.ELSE();
            const conditionLabel: string = node.text.toLowerCase();
            const childTemplateBodyResult: string[] = [];
            const templateBodies = this.visit(ifRule.normalTemplateBody());
            for (const templateBody of templateBodies) {
                childTemplateBodyResult.push(templateBody[0]);
            }

            if (expressions !== undefined && expressions.length > 0) {
                if (expressions[0].text !== undefined) {
                    result.set(conditionLabel.toUpperCase().concat(' ') + expressions[0].text, childTemplateBodyResult);
                }
            } else {
                result.set('ELSE:', childTemplateBodyResult);
            }
        }

        return result;
    }

    /**
     * Visit a parse tree produced by the switchCaseBody labeled alternative in LGTemplateParser.body.
     *
     * @param context The parse tree.
     * @returns The result of visiting the switch case body.
     */
    visitSwitchCaseBody(context: SwitchCaseBodyContext): Map<string, string[]> {
        const result = new Map<string, string[]>();
        const switchCaseNodes: SwitchCaseRuleContext[] = context.switchCaseTemplateBody().switchCaseRule();
        for (const iterNode of switchCaseNodes) {
            const expressions = iterNode.switchCaseStat().expression();
            const switchCaseStat: SwitchCaseStatContext = iterNode.switchCaseStat();
            const switchExpr: boolean = switchCaseStat.SWITCH() !== undefined;
            const caseExpr: boolean = switchCaseStat.CASE() !== undefined;

            const node: TerminalNode = switchExpr
                ? switchCaseStat.SWITCH()
                : caseExpr
                  ? switchCaseStat.CASE()
                  : switchCaseStat.DEFAULT();
            if (switchExpr) {
                continue;
            }
            const conditionLabel: string = node.text.toLowerCase();
            const childTemplateBodyResult: string[] = [];
            const templateBodies = this.visit(iterNode.normalTemplateBody());
            for (const templateBody of templateBodies) {
                childTemplateBodyResult.push(templateBody[0]);
            }

            if (caseExpr) {
                result.set(conditionLabel.toUpperCase().concat(' ') + expressions[0].text, childTemplateBodyResult);
            } else {
                result.set('DEFALUT:', childTemplateBodyResult);
            }
        }

        return result;
    }

    /**
     * Gets the default value returned by visitor methods.
     *
     * @returns Empty Map<string,  string[]>.
     */
    protected defaultResult(): Map<string, string[]> {
        return new Map<string, string[]>();
    }
}

1	/**
2	* @module botbuilder-lg
3	*/
4	/**
5	* Copyright (c) Microsoft Corporation. All rights reserved.
6	* Licensed under the MIT License.
7	*/
8	import { AbstractParseTreeVisitor, TerminalNode } from 'antlr4ts/tree';	1✔
9	import keyBy from 'lodash/keyBy';	1✔
10	import { LGTemplateParserVisitor } from './generated/LGTemplateParserVisitor';
11	import { Template } from './template';
12
13	import {
14	IfConditionContext,
15	IfConditionRuleContext,
16	IfElseBodyContext,
17	NormalTemplateBodyContext,
18	StructuredBodyContext,
19	SwitchCaseBodyContext,
20	SwitchCaseRuleContext,
21	SwitchCaseStatContext,
22	} from './generated/LGTemplateParser';
23
24	/**
25	* Lg template extracter.
26	*/
27	export class Extractor	1✔
28	extends AbstractParseTreeVisitor<Map<string, string[]>>
29	implements LGTemplateParserVisitor<Map<string, string[]>>
30	{
31	readonly templates: Template[];
32
33	readonly templateMap: Record<string, Template>;
34
35	/**
36	* Creates a new instance of the [Extractor](xref:botbuilder-lg.Extractor) class.
37	*
38	* @param templates Template list.
39	*/
40	constructor(templates: Template[]) {
41	super();	×
42	this.templates = templates;	×
UNCOV 43	this.templateMap = keyBy(templates, (t: Template): string => t.name);	×
44	}
45
46	/**
47	* Extracts the templates and returns a map with their names and bodies.
48	*
49	* @returns Map object with template names and bodies.
50	*/
51	extract(): Map<string, string[] \| Map<string, string[]>>[] {
52	const result: Map<string, string[] \| Map<string, string[]>>[] = [];	×
53	this.templates.forEach((template: Template) => {	×
54	const templateResult = new Map<string, string[] \| Map<string, string[]>>();	×
55	const templateName: string = template.name;	×
56	const templateBodies = this.visit(template.templateBodyParseTree);	×
57	let isNormalTemplate = true;	×
58	templateBodies.forEach(	×
UNCOV 59	(templateBody) => (isNormalTemplate = isNormalTemplate && templateBody === undefined),	×
60	);
61
62	if (isNormalTemplate) {	×
63	const templates: string[] = [];	×
64	for (const templateBody of templateBodies) {	×
UNCOV 65	templates.push(templateBody[0]);	×
66	}
UNCOV 67	templateResult.set(templateName, templates);	×
68	} else {
UNCOV 69	templateResult.set(templateName, templateBodies);	×
70	}
71
UNCOV 72	result.push(templateResult);	×
73	});
74
UNCOV 75	return result;	×
76	}
77
78	/**
79	* Visit a parse tree produced by LGTemplateParser.normalTemplateBody.
80	*
81	* @param context The parse tree.
82	* @returns The result of visiting the normal template body.
83	*/
84	visitNormalTemplateBody(context: NormalTemplateBodyContext): Map<string, string[]> {
85	const result = new Map<string, string[]>();	×
86	for (const templateStr of context.templateString()) {	×
UNCOV 87	result.set(templateStr.normalTemplateString().text, undefined);	×
88	}
89
UNCOV 90	return result;	×
91	}
92
93	/**
94	* Visit a parse tree produced by the structuredBody labeled alternative in LGTemplateParser.body.
95	*
96	* @param context The parse tree.
97	* @returns The result of visiting the structured body.
98	*/
99	visitStructuredBody(context: StructuredBodyContext): Map<string, string[]> {
100	const result = new Map<string, string[]>();	×
101	const lineStart = ' ';	×
102	const structName = context.structuredTemplateBody().structuredBodyNameLine().text;	×
103	let fullStr = structName + '\n';	×
UNCOV 104	context	×
105	.structuredTemplateBody()
106	.structuredBodyContentLine()
107	.forEach((line): string => (fullStr += lineStart + line.text + '\n'));	×
UNCOV 108	fullStr += context.structuredTemplateBody().structuredBodyEndLine().text;	×
109
110	result.set(fullStr, undefined);	×
UNCOV 111	return result;	×
112	}
113
114	/**
115	* Visit a parse tree produced by the ifElseBody labeled alternative in LGTemplateParser.body.
116	*
117	* @param context The parse tree.
118	* @returns The result of visiting the if else body.
119	*/
120	visitIfElseBody(context: IfElseBodyContext): Map<string, string[]> {
121	const result = new Map<string, string[]>();	×
122	const ifRules: IfConditionRuleContext[] = context.ifElseTemplateBody().ifConditionRule();	×
123	for (const ifRule of ifRules) {	×
124	const expressions = ifRule.ifCondition().expression();	×
125	const conditionNode: IfConditionContext = ifRule.ifCondition();	×
126	const ifExpr: boolean = conditionNode.IF() !== undefined;	×
UNCOV 127	const elseIfExpr: boolean = conditionNode.ELSEIF() !== undefined;	×
128
UNCOV 129	const node: TerminalNode = ifExpr	×
130	? conditionNode.IF()	×
131	: elseIfExpr
132	? conditionNode.ELSEIF()	×
133	: conditionNode.ELSE();
134	const conditionLabel: string = node.text.toLowerCase();	×
135	const childTemplateBodyResult: string[] = [];	×
136	const templateBodies = this.visit(ifRule.normalTemplateBody());	×
137	for (const templateBody of templateBodies) {	×
UNCOV 138	childTemplateBodyResult.push(templateBody[0]);	×
139	}
140
141	if (expressions !== undefined && expressions.length > 0) {	×
142	if (expressions[0].text !== undefined) {	×
UNCOV 143	result.set(conditionLabel.toUpperCase().concat(' ') + expressions[0].text, childTemplateBodyResult);	×
144	}
145	} else {
UNCOV 146	result.set('ELSE:', childTemplateBodyResult);	×
147	}
148	}
149
UNCOV 150	return result;	×
151	}
152
153	/**
154	* Visit a parse tree produced by the switchCaseBody labeled alternative in LGTemplateParser.body.
155	*
156	* @param context The parse tree.
157	* @returns The result of visiting the switch case body.
158	*/
159	visitSwitchCaseBody(context: SwitchCaseBodyContext): Map<string, string[]> {
160	const result = new Map<string, string[]>();	×
161	const switchCaseNodes: SwitchCaseRuleContext[] = context.switchCaseTemplateBody().switchCaseRule();	×
162	for (const iterNode of switchCaseNodes) {	×
163	const expressions = iterNode.switchCaseStat().expression();	×
164	const switchCaseStat: SwitchCaseStatContext = iterNode.switchCaseStat();	×
165	const switchExpr: boolean = switchCaseStat.SWITCH() !== undefined;	×
UNCOV 166	const caseExpr: boolean = switchCaseStat.CASE() !== undefined;	×
167
UNCOV 168	const node: TerminalNode = switchExpr	×
169	? switchCaseStat.SWITCH()	×
170	: caseExpr
171	? switchCaseStat.CASE()	×
172	: switchCaseStat.DEFAULT();
173	if (switchExpr) {	×
UNCOV 174	continue;	×
175	}
176	const conditionLabel: string = node.text.toLowerCase();	×
177	const childTemplateBodyResult: string[] = [];	×
178	const templateBodies = this.visit(iterNode.normalTemplateBody());	×
179	for (const templateBody of templateBodies) {	×
UNCOV 180	childTemplateBodyResult.push(templateBody[0]);	×
181	}
182
183	if (caseExpr) {	×
UNCOV 184	result.set(conditionLabel.toUpperCase().concat(' ') + expressions[0].text, childTemplateBodyResult);	×
185	} else {
UNCOV 186	result.set('DEFALUT:', childTemplateBodyResult);	×
187	}
188	}
189
UNCOV 190	return result;	×
191	}
192
193	/**
194	* Gets the default value returned by visitor methods.
195	*
196	* @returns Empty Map<string, string[]>.
197	*/
198	protected defaultResult(): Map<string, string[]> {
UNCOV 199	return new Map<string, string[]>();	×
200	}
201	}

microsoft / botbuilder-js / 12302726031

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