2578

pending completion

Build # 2578

Build Type

Pull #853

travis-ci-com

Committed by

web-flow

Commit Message

Merge c79153a32 into 9e162a61e

Pull Request Pull Request #853: utils/describe: avoid using "program"-type examples for confirmations

Run Details

10515 of 21201 branches covered (49.6%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 1 file covered. (100.0%)

11 existing lines in 7 files now uncovered.

25053 of 41848 relevant lines covered (59.87%)

361112.18 hits per line

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

69.92

/lib/templates/dialogue_acts/coref-questions.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>


import assert from 'assert';

import { Ast, } from 'thingtalk';

import * as C from '../ast_manip';
import {
    ContextInfo,
    addQuery,
} from '../state_manip';
import {
    queryRefinement,
    refineFilterToAnswerQuestion,
} from './refinement-helpers';
import type { Recommendation } from './recommendation';
import type { ListProposal } from './list-proposal';

export type UserSearchQuestionForList = [Ast.EntityValue|Ast.NumberValue|null, C.ParamSlot[]];

export function userSearchQuestionForListKeyFn([name, questions] : UserSearchQuestionForList) {
    if (questions.length === 0)
        return { idType: null, functionName: null };

    return {
        idType: name ? name.getType() : null,
        functionName: questions[0].schema.qualifiedName
    };
}

function areQuestionsValidForContext(ctx : ContextInfo, questions : C.ParamSlot[]) {
    if (ctx.resultInfo!.isAggregation)
        return null;

    const schema = ctx.currentFunction!;

    // if the function only contains one parameter, do not generate projection for it
    if (C.countInputOutputParams(schema).output === 1)
        return null;

    for (const q of questions) {
        if (!C.isSameFunction(schema, q.schema))
            return false;
        const arg = schema.getArgument(q.name);
        if (!arg || arg.is_input)
            return false;
    }
    return true;
}

function removeMonitorInner(expr : Ast.Expression) : Ast.Expression {
    if (expr instanceof Ast.MonitorExpression)
        return expr.expression;

    if (expr instanceof Ast.FilterExpression ||
        expr instanceof Ast.ProjectionExpression)
        return removeMonitorInner(expr.expression);

    return expr;
}

function removeMonitor(expr : Ast.ChainExpression) : Ast.ChainExpression {
    if (expr instanceof Ast.ChainExpression &&
        expr.first.schema!.functionType === 'stream') {
        const withoutMonitor = removeMonitorInner(expr.first);
        const clone = expr.expressions.slice();
        clone[0] = withoutMonitor;
        return new Ast.ChainExpression(null, clone, expr.schema);
    }

    return expr;
}

function recommendationSearchQuestionReply(ctx : ContextInfo, questions : C.ParamSlot[]) {
    const proposal = ctx.aux as Recommendation;
    const { topResult, info, } = proposal;
    if (!topResult.value.id)
        return null;
    if (info !== null) {
        for (const q of questions) {
            if (info.has(q.name))
                return null;
        }
    }

    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = removeMonitor(currentStmt.expression);
    const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);
    const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,
        questions.map((q) => q.name));
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function learnMoreSearchQuestionReply(ctx : ContextInfo, questions : C.ParamSlot[]) {
    const topResult = ctx.results![0];
    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = removeMonitor(currentStmt.expression);
    if (!topResult.value.id)
        return null;
    const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);
    const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,
        questions.map((q) => q.name));
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function displayResultSearchQuestionReply(ctx : ContextInfo, questions : C.ParamSlot[]) {
    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = removeMonitor(currentStmt.expression);
    const newTable = queryRefinement(currentTable, null, refineFilterToAnswerQuestion,
        questions.map((q) => q.name));
    if (newTable === null)
        return null;
    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function listProposalSearchQuestionReply(ctx : ContextInfo, [name, questions] : [Ast.Value|null, C.ParamSlot[]]) {
    const proposal = ctx.aux as ListProposal;
    const { results, info } = proposal;

    if (name !== null) {
        let good = false;
        for (const result of results) {
            if (!result.value.id)
                continue;
            if (result.value.id.equals(name)) {
                good = true;
                break;
            }
        }
        if (!good)
            return null;
    }

    if (info !== null) {
        for (const q of questions) {
            if (info.has(q.name))
                return null;
        }
    }

    if (!areQuestionsValidForContext(ctx, questions))
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    let newTable;
    if (name !== null) {
        const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
        newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,
            questions.map((q) => q.name));
    } else {
        newTable = queryRefinement(currentTable, null, null,
            questions.map((q) => q.name));
    }
    if (newTable === null)
        return null;

    return addQuery(ctx, 'execute', newTable, 'accepted');
}

function corefConstant(ctx : ContextInfo, base : Ast.Expression, param : C.ParamSlot) {
    const previous = ctx.previousDomain;
    assert(previous);
    if (!previous.results || previous.results.results.length === 0)
        return null;
    const ctxStmt = previous.stmt;
    const ctxSchema = ctxStmt.expression.schema!;
    if (!ctxSchema.class) // FIXME not sure how this happens...
        return null;
    if (ctxSchema.class.name !== base.schema!.class!.name)
        return null;
    if (!C.isSameFunction(ctxSchema, param.schema))
        return null;
    const result = previous.results.results[0];
    if (!result.value[param.name])
        return null;
    return result.value[param.name];
}

function booleanQuestion(base : Ast.Expression|null, slot : C.FilterSlot) : C.ParamSlot[]|null {
    if (base !== null) {
        if (!C.isSameFunction(base.schema!, slot.schema))
            return null;
    }

    const ast = slot.ast;
    if (!(ast instanceof Ast.AtomBooleanExpression)) {
        assert(ast instanceof Ast.AndBooleanExpression);
        assert(ast.operands.length === 2);
        const [op1, op2] = [ast.operands[0], ast.operands[1]];
        assert(op1 instanceof Ast.AtomBooleanExpression);
        assert(op2 instanceof Ast.AtomBooleanExpression);
        assert(op1.name === op2.name);
        return [{
            schema: slot.schema,
            type: slot.ptype,
            filterable: slot.schema.getArgument(op1.name)!.getImplementationAnnotation<boolean>('filterable') ?? true,
            symmetric: slot.schema.getArgument(op1.name)!.getImplementationAnnotation<boolean>('symmetric') ?? false,
            name: op1.name,
            ast: new Ast.Value.VarRef(op1.name)
        }];
    }
    if (ast.name === 'id')
        return null;
    return [{
        schema: slot.schema,
        type: slot.ptype,
        filterable: slot.schema.getArgument(ast.name)!.getImplementationAnnotation<boolean>('filterable') ?? true,
        symmetric: slot.schema.getArgument(ast.name)!.getImplementationAnnotation<boolean>('symmetric') ?? false,
        name: ast.name,
        ast: new Ast.Value.VarRef(ast.name),
    }];
}

export {
    recommendationSearchQuestionReply,
    displayResultSearchQuestionReply,
    learnMoreSearchQuestionReply,
    listProposalSearchQuestionReply,
    corefConstant,
    booleanQuestion
};

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21
22	import assert from 'assert';	102✔
23
24	import { Ast, } from 'thingtalk';	102✔
25
26	import * as C from '../ast_manip';	102✔
27	import {	102✔
28	ContextInfo,
29	addQuery,
30	} from '../state_manip';
31	import {	102✔
32	queryRefinement,
33	refineFilterToAnswerQuestion,
34	} from './refinement-helpers';
35	import type { Recommendation } from './recommendation';
36	import type { ListProposal } from './list-proposal';
37
38	export type UserSearchQuestionForList = [Ast.EntityValue\|Ast.NumberValue\|null, C.ParamSlot[]];
39
40	export function userSearchQuestionForListKeyFn([name, questions] : UserSearchQuestionForList) {	102✔
41	if (questions.length === 0)	5,969!
42	return { idType: null, functionName: null };	×
43
44	return {	5,969✔
45	idType: name ? name.getType() : null,	5,969!
46	functionName: questions[0].schema.qualifiedName
47	};
48	}
49
50	function areQuestionsValidForContext(ctx : ContextInfo, questions : C.ParamSlot[]) {
51	if (ctx.resultInfo!.isAggregation)	73,594✔
52	return null;	18,346✔
53
54	const schema = ctx.currentFunction!;	55,248✔
55
56	// if the function only contains one parameter, do not generate projection for it
57	if (C.countInputOutputParams(schema).output === 1)	55,248✔
58	return null;	3,619✔
59
60	for (const q of questions) {	51,629✔
61	if (!C.isSameFunction(schema, q.schema))	56,782!
62	return false;	×
63	const arg = schema.getArgument(q.name);	56,782✔
64	if (!arg \|\| arg.is_input)	56,782✔
65	return false;	17,159✔
66	}
67	return true;	34,470✔
68	}
69
70	function removeMonitorInner(expr : Ast.Expression) : Ast.Expression {
71	if (expr instanceof Ast.MonitorExpression)	×
72	return expr.expression;	×
73
74	if (expr instanceof Ast.FilterExpression \|\|	×
75	expr instanceof Ast.ProjectionExpression)
76	return removeMonitorInner(expr.expression);	×
77
78	return expr;	×
79	}
80
81	function removeMonitor(expr : Ast.ChainExpression) : Ast.ChainExpression {
82	if (expr instanceof Ast.ChainExpression &&	18,315!
83	expr.first.schema!.functionType === 'stream') {
84	const withoutMonitor = removeMonitorInner(expr.first);	×
85	const clone = expr.expressions.slice();	×
86	clone[0] = withoutMonitor;	×
87	return new Ast.ChainExpression(null, clone, expr.schema);	×
88	}
89
90	return expr;	18,315✔
91	}
92
93	function recommendationSearchQuestionReply(ctx : ContextInfo, questions : C.ParamSlot[]) {
94	const proposal = ctx.aux as Recommendation;	213,333✔
95	const { topResult, info, } = proposal;	213,333✔
96	if (!topResult.value.id)	213,333✔
97	return null;	177,320✔
98	if (info !== null) {	36,013✔
99	for (const q of questions) {	28,758✔
100	if (info.has(q.name))	30,729✔
101	return null;	12,731✔
102	}
103	}
104
105	if (!areQuestionsValidForContext(ctx, questions))	23,282✔
106	return null;	7,328✔
107
108	const currentStmt = ctx.current!.stmt;	15,954✔
109	const currentTable = removeMonitor(currentStmt.expression);	15,954✔
110	const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);	15,954✔
111	const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,	15,954✔
112	questions.map((q) => q.name));	17,499✔
113	if (newTable === null)	15,954!
114	return null;	×
115	return addQuery(ctx, 'execute', newTable, 'accepted');	15,954✔
116	}
117
118	function learnMoreSearchQuestionReply(ctx : ContextInfo, questions : C.ParamSlot[]) {
119	const topResult = ctx.results![0];	3,200✔
120	if (!areQuestionsValidForContext(ctx, questions))	3,200!
121	return null;	3,200✔
122
123	const currentStmt = ctx.current!.stmt;	×
124	const currentTable = removeMonitor(currentStmt.expression);	×
125	if (!topResult.value.id)	×
126	return null;	×
127	const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', topResult.value.id);	×
128	const newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,	×
129	questions.map((q) => q.name));	×
130	if (newTable === null)	×
131	return null;	×
132	return addQuery(ctx, 'execute', newTable, 'accepted');	×
133	}
134
135	function displayResultSearchQuestionReply(ctx : ContextInfo, questions : C.ParamSlot[]) {
136	if (!areQuestionsValidForContext(ctx, questions))	21,126✔
137	return null;	18,765✔
138
139	const currentStmt = ctx.current!.stmt;	2,361✔
140	const currentTable = removeMonitor(currentStmt.expression);	2,361✔
141	const newTable = queryRefinement(currentTable, null, refineFilterToAnswerQuestion,	2,361✔
142	questions.map((q) => q.name));	4,692✔
143	if (newTable === null)	2,361!
144	return null;	×
145	return addQuery(ctx, 'execute', newTable, 'accepted');	2,361✔
146	}
147
148	function listProposalSearchQuestionReply(ctx : ContextInfo, [name, questions] : [Ast.Value\|null, C.ParamSlot[]]) {
149	const proposal = ctx.aux as ListProposal;	28,481✔
150	const { results, info } = proposal;	28,481✔
151
152	if (name !== null) {	28,481!
153	let good = false;	×
154	for (const result of results) {	×
155	if (!result.value.id)	×
156	continue;	×
157	if (result.value.id.equals(name)) {	×
158	good = true;	×
159	break;	×
160	}
161	}
162	if (!good)	×
163	return null;	×
164	}
165
166	if (info !== null) {	28,481✔
167	for (const q of questions) {	9,739✔
168	if (info.has(q.name))	10,143✔
169	return null;	2,495✔
170	}
171	}
172
173	if (!areQuestionsValidForContext(ctx, questions))	25,986✔
174	return null;	9,831✔
175
176	const currentStmt = ctx.current!.stmt;	16,155✔
177	const currentTable = currentStmt.expression;	16,155✔
178	let newTable;
179	if (name !== null) {	16,155!
180	const newFilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	×
181	newTable = queryRefinement(currentTable, newFilter, refineFilterToAnswerQuestion,	×
182	questions.map((q) => q.name));	×
183	} else {
184	newTable = queryRefinement(currentTable, null, null,	16,155✔
185	questions.map((q) => q.name));	17,361✔
186	}
187	if (newTable === null)	16,155!
188	return null;	×
189
190	return addQuery(ctx, 'execute', newTable, 'accepted');	16,155✔
191	}
192
193	function corefConstant(ctx : ContextInfo, base : Ast.Expression, param : C.ParamSlot) {
194	const previous = ctx.previousDomain;	5,461✔
195	assert(previous);	5,461✔
196	if (!previous.results \|\| previous.results.results.length === 0)	5,461✔
197	return null;	184✔
198	const ctxStmt = previous.stmt;	5,277✔
199	const ctxSchema = ctxStmt.expression.schema!;	5,277✔
200	if (!ctxSchema.class) // FIXME not sure how this happens...	5,277!
201	return null;	×
202	if (ctxSchema.class.name !== base.schema!.class!.name)	5,277✔
203	return null;	3,627✔
204	if (!C.isSameFunction(ctxSchema, param.schema))	1,650✔
205	return null;	1,585✔
206	const result = previous.results.results[0];	65✔
207	if (!result.value[param.name])	65✔
208	return null;	2✔
209	return result.value[param.name];	63✔
210	}
211
212	function booleanQuestion(base : Ast.Expression\|null, slot : C.FilterSlot) : C.ParamSlot[]\|null {
213	if (base !== null) {	79,387✔
214	if (!C.isSameFunction(base.schema!, slot.schema))	69,475!
215	return null;	×
216	}
217
218	const ast = slot.ast;	79,387✔
219	if (!(ast instanceof Ast.AtomBooleanExpression)) {	79,387✔
220	assert(ast instanceof Ast.AndBooleanExpression);	31,538✔
221	assert(ast.operands.length === 2);	31,538✔
222	const [op1, op2] = [ast.operands[0], ast.operands[1]];	31,538✔
223	assert(op1 instanceof Ast.AtomBooleanExpression);	31,538✔
224	assert(op2 instanceof Ast.AtomBooleanExpression);	31,538✔
225	assert(op1.name === op2.name);	31,538✔
226	return [{	31,538✔
227	schema: slot.schema,
228	type: slot.ptype,
229	filterable: slot.schema.getArgument(op1.name)!.getImplementationAnnotation<boolean>('filterable') ?? true,	94,614!
230	symmetric: slot.schema.getArgument(op1.name)!.getImplementationAnnotation<boolean>('symmetric') ?? false,	94,614!
231	name: op1.name,
232	ast: new Ast.Value.VarRef(op1.name)
233	}];
234	}
235	if (ast.name === 'id')	47,849!
UNCOV 236	return null;	×
237	return [{	47,849✔
238	schema: slot.schema,
239	type: slot.ptype,
240	filterable: slot.schema.getArgument(ast.name)!.getImplementationAnnotation<boolean>('filterable') ?? true,	143,547✔
241	symmetric: slot.schema.getArgument(ast.name)!.getImplementationAnnotation<boolean>('symmetric') ?? false,	143,547!
242	name: ast.name,
243	ast: new Ast.Value.VarRef(ast.name),
244	}];
245	}
246
247	export {
248	recommendationSearchQuestionReply,	102✔
249	displayResultSearchQuestionReply,	102✔
250	learnMoreSearchQuestionReply,	102✔
251	listProposalSearchQuestionReply,	102✔
252	corefConstant,	102✔
253	booleanQuestion	102✔
254	};

stanford-oval / genie-toolkit / 2578

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