1995

pending completion

Build # 1995

Build Type

Pull #623

travis-ci-com

Committed by

web-flow

Commit Message

Merge 3584b7168 into 275da76f5

Pull Request Pull Request #623: [WIP] Timers & Reminders

Run Details

12266 of 25922 branches covered (47.32%)

Branch coverage included in aggregate %.

7 of 10 new or added lines in 1 file covered. (70.0%)

20 existing lines in 6 files now uncovered.

28537 of 48721 relevant lines covered (58.57%)

434356.99 hits per line

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

79.65

/languages/thingtalk/dialogue_acts/empty-search.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 { Ast, } from 'thingtalk';

import * as C from '../ast_manip';

import {
    ContextInfo,
    makeAgentReply,
    makeSimpleState,
    addNewStatement,
    addQuery,
    acceptAllProposedStatements
} from '../state_manip';
import {
    queryRefinement,
    refineFilterForEmptySearch,
    RefineFilterCallback
} from './refinement-helpers';
import {
    isValidSearchQuestion
} from './common';

type EmptySearch = [Ast.Expression|null, C.ParamSlot|null, boolean];

/**
 * Agent dialogue act: a search command returned no result.
 *
 * @param ctx - the current context
 * @param base - the base table used in the reply
 * @param question - a search question used in the reply
 */
export function makeEmptySearchError(ctx : ContextInfo, [base, question, offerMonitor] : EmptySearch) {
    if (base !== null && !C.isSameFunction(base.schema!, ctx.currentTableFunction!))
        return null;
    if (question !== null && !C.isSameFunction(ctx.currentTableFunction!, question.schema))
        return null;

    let type, state;
    if (question !== null) {
        if (!isGoodEmptySearchQuestion(ctx, question))
            return null;

        const arg = ctx.currentTableFunction!.getArgument(question.name);
        if (!arg)
            return null;
        type = arg.type;
        state = makeSimpleState(ctx, 'sys_empty_search_question', [question.name]);
    } else if (offerMonitor) {
        const monitor = C.tableToStream(ctx.current!.stmt.lastQuery!);
        if (!monitor)
            return null;
        state = addNewStatement(ctx, 'sys_empty_search', null, 'proposed', monitor);
    } else {
        type = null;
        state = makeSimpleState(ctx, 'sys_empty_search', null);
    }
    return makeAgentReply(ctx, state, [base, question], type);
}

function isGoodEmptySearchQuestion(ctx : ContextInfo, question : C.ParamSlot) {
    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    if (!isValidSearchQuestion(currentTable, [question]))
        return false;

    const ctxFilterTable = C.findFilterExpression(currentTable);
    if (!ctxFilterTable || !C.filterUsesParam(ctxFilterTable.filter, question.name))
        return false;

    return true;
}

function emptySearchChangePhraseCommon(ctx : ContextInfo,
                                       newFilter : Ast.BooleanExpression,
                                       refineFilter : RefineFilterCallback) {
    const currentStmt = ctx.current!.stmt;
    const currentExpression = currentStmt.expression;
    const newExpression = queryRefinement(currentExpression, newFilter, refineFilter, null);
    if (newExpression === null)
        return null;

    // XXX: do we want to remove any sort/index?
    return addQuery(ctx, 'execute', newExpression, 'accepted');
}

/**
 * User dialogue act: in response to an empty search, the user changes their constraints.
 *
 * The "precise" variant explicitly contains a reference to a table, which must be the same
 * as the context.
 */
export function preciseEmptySearchChangeRequest(ctx : ContextInfo,
                                                phrase : Ast.Expression) {
    if (!(phrase instanceof Ast.FilterExpression))
        return null;
    const [, param] = ctx.aux as EmptySearch;
    if (!C.isSameFunction(ctx.currentTableFunction!, phrase.schema!))
        return null;
    if (param !== null && !C.filterUsesParam(phrase.filter, param.name))
        return null;

    return emptySearchChangePhraseCommon(ctx, phrase.filter, refineFilterForEmptySearch);
}

/**
 * User dialogue act: in response to an empty search, the user changes their constraints.
 *
 * The "imprecise" variant only contains a value and optionally a parameter name.
 * The table is inferred from the context.
 */
export function impreciseEmptySearchChangeRequest(ctx : ContextInfo,
                                                  answer : Ast.Value|C.FilterSlot) {
    const [base, param] = ctx.aux as EmptySearch;
    // because we're imprecise, we're only valid if the agent asked a specific question
    if (base === null || param === null)
        return null;
    let answerFilter : C.FilterSlot|null;
    if (answer instanceof Ast.Value)
        answerFilter = C.makeFilter(ctx.loader, param, '==', answer);
    else
        answerFilter = answer;
    if (answerFilter === null || !(answerFilter instanceof Ast.AtomBooleanExpression))
        return null;
    if (answerFilter.name !== param.name)
        return null;
    if (!C.checkFilter(base, answerFilter))
        return null;

    return emptySearchChangePhraseCommon(ctx, answerFilter, refineFilterForEmptySearch);
}

/**
 * User dialogue act: in response to an empty search where the agent proposed a statement,
 * the user accepts the statement.
 */
export function acceptEmptySearchOffer(ctx : ContextInfo) {
    return acceptAllProposedStatements(ctx);
}

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	import { Ast, } from 'thingtalk';	5✔
22
23	import * as C from '../ast_manip';	5✔
24
25	import {	5✔
26	ContextInfo,
27	makeAgentReply,
28	makeSimpleState,
29	addNewStatement,
30	addQuery,
31	acceptAllProposedStatements
32	} from '../state_manip';
33	import {	5✔
34	queryRefinement,
35	refineFilterForEmptySearch,
36	RefineFilterCallback
37	} from './refinement-helpers';
38	import {	5✔
39	isValidSearchQuestion
40	} from './common';
41
42	type EmptySearch = [Ast.Expression\|null, C.ParamSlot\|null, boolean];
43
44	/**
45	* Agent dialogue act: a search command returned no result.
46	*
47	* @param ctx - the current context
48	* @param base - the base table used in the reply
49	* @param question - a search question used in the reply
50	*/
51	export function makeEmptySearchError(ctx : ContextInfo, [base, question, offerMonitor] : EmptySearch) {	5✔
52	if (base !== null && !C.isSameFunction(base.schema!, ctx.currentTableFunction!))	13,723✔
53	return null;	7,820✔
54	if (question !== null && !C.isSameFunction(ctx.currentTableFunction!, question.schema))	5,903✔
55	return null;	4,277✔
56
57	let type, state;
58	if (question !== null) {	1,626✔
59	if (!isGoodEmptySearchQuestion(ctx, question))	1,330✔
60	return null;	765✔
61
62	const arg = ctx.currentTableFunction!.getArgument(question.name);	565✔
63	if (!arg)	565!
64	return null;	×
65	type = arg.type;	565✔
66	state = makeSimpleState(ctx, 'sys_empty_search_question', [question.name]);	565✔
67	} else if (offerMonitor) {	296!
UNCOV 68	const monitor = C.tableToStream(ctx.current!.stmt.lastQuery!);	×
UNCOV 69	if (!monitor)	×
70	return null;	×
UNCOV 71	state = addNewStatement(ctx, 'sys_empty_search', null, 'proposed', monitor);	×
72	} else {
73	type = null;	296✔
74	state = makeSimpleState(ctx, 'sys_empty_search', null);	296✔
75	}
76	return makeAgentReply(ctx, state, [base, question], type);	861✔
77	}
78
79	function isGoodEmptySearchQuestion(ctx : ContextInfo, question : C.ParamSlot) {
80	const currentStmt = ctx.current!.stmt;	1,330✔
81	const currentTable = currentStmt.expression;	1,330✔
82	if (!isValidSearchQuestion(currentTable, [question]))	1,330✔
83	return false;	419✔
84
85	const ctxFilterTable = C.findFilterExpression(currentTable);	911✔
86	if (!ctxFilterTable \|\| !C.filterUsesParam(ctxFilterTable.filter, question.name))	911✔
87	return false;	346✔
88
89	return true;	565✔
90	}
91
92	function emptySearchChangePhraseCommon(ctx : ContextInfo,
93	newFilter : Ast.BooleanExpression,
94	refineFilter : RefineFilterCallback) {
95	const currentStmt = ctx.current!.stmt;	25,269✔
96	const currentExpression = currentStmt.expression;	25,269✔
97	const newExpression = queryRefinement(currentExpression, newFilter, refineFilter, null);	25,269✔
98	if (newExpression === null)	25,269✔
99	return null;	3,331✔
100
101	// XXX: do we want to remove any sort/index?
102	return addQuery(ctx, 'execute', newExpression, 'accepted');	21,938✔
103	}
104
105	/**
106	* User dialogue act: in response to an empty search, the user changes their constraints.
107	*
108	* The "precise" variant explicitly contains a reference to a table, which must be the same
109	* as the context.
110	*/
111	export function preciseEmptySearchChangeRequest(ctx : ContextInfo,	5✔
112	phrase : Ast.Expression) {
113	if (!(phrase instanceof Ast.FilterExpression))	36,687!
114	return null;	×
115	const [, param] = ctx.aux as EmptySearch;	36,687✔
116	if (!C.isSameFunction(ctx.currentTableFunction!, phrase.schema!))	36,687!
117	return null;	×
118	if (param !== null && !C.filterUsesParam(phrase.filter, param.name))	36,687✔
119	return null;	11,418✔
120
121	return emptySearchChangePhraseCommon(ctx, phrase.filter, refineFilterForEmptySearch);	25,269✔
122	}
123
124	/**
125	* User dialogue act: in response to an empty search, the user changes their constraints.
126	*
127	* The "imprecise" variant only contains a value and optionally a parameter name.
128	* The table is inferred from the context.
129	*/
130	export function impreciseEmptySearchChangeRequest(ctx : ContextInfo,	5✔
131	answer : Ast.Value\|C.FilterSlot) {
132	const [base, param] = ctx.aux as EmptySearch;	86,115✔
133	// because we're imprecise, we're only valid if the agent asked a specific question
134	if (base === null \|\| param === null)	86,115✔
135	return null;	62,459✔
136	let answerFilter : C.FilterSlot\|null;
137	if (answer instanceof Ast.Value)	23,656✔
138	answerFilter = C.makeFilter(ctx.loader, param, '==', answer);	9,590✔
139	else
140	answerFilter = answer;	14,066✔
141	if (answerFilter === null \|\| !(answerFilter instanceof Ast.AtomBooleanExpression))	23,656!
142	return null;	23,656✔
143	if (answerFilter.name !== param.name)	×
144	return null;	×
145	if (!C.checkFilter(base, answerFilter))	×
146	return null;	×
147
148	return emptySearchChangePhraseCommon(ctx, answerFilter, refineFilterForEmptySearch);	×
149	}
150
151	/**
152	* User dialogue act: in response to an empty search where the agent proposed a statement,
153	* the user accepts the statement.
154	*/
155	export function acceptEmptySearchOffer(ctx : ContextInfo) {	5✔
156	return acceptAllProposedStatements(ctx);	77✔
157	}

stanford-oval / genie-toolkit / 1995

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