1903

pending completion

Build # 1903

Build Type

Pull #567

travis-ci-com

Committed by

web-flow

Commit Message

Merge 3ab247ba1 into a9b350735

Pull Request Pull Request #567: Notification refactoring

Run Details

12039 of 25552 branches covered (47.12%)

Branch coverage included in aggregate %.

153 of 238 new or added lines in 14 files covered. (64.29%)

45 existing lines in 11 files now uncovered.

28222 of 48215 relevant lines covered (58.53%)

385428.77 hits per line

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

77.99

/languages/thingtalk/dialogue_acts/list-proposal.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 ThingpediaLoader from '../load-thingpedia';

import {
    AgentReplyOptions,
    ContextInfo,
    NameList,
    makeAgentReply,
    makeSimpleState,
    addActionParam,
    addAction,
    addQuery,
} from '../state_manip';
import {
    isInfoPhraseCompatibleWithResult,
    findChainParam
} from './common';
import {
    queryRefinement,
    refineFilterToAnswerQuestionOrChangeFilter,
    combinePreambleAndRequest,
    proposalReply,
} from './refinement-helpers';
import {
    SlotBag
} from '../slot_bag';
import {
    DirectAnswerPhrase
} from './results';

export type ListProposal = [Ast.DialogueHistoryResultItem[], SlotBag|null, Ast.Invocation|null, boolean];

export function listProposalKeyFn([results, info, action, hasLearnMore] : ListProposal) {
    return {
        idType: results[0].value.id ? results[0].value.id.getType() : null,
        queryName: info ? info.schema!.qualifiedName : null,
        actionName: action ? action.schema!.qualifiedName : null,
    };
}

function checkListProposal(nameList : NameList, info : SlotBag|null, hasLearnMore : boolean) : ListProposal|null {
    const { ctx, results } = nameList;
    const resultType = results[0].value.id.getType();

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if ((last instanceof Ast.SliceExpression ||
        (last instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression)) &&
        results.length !== ctx.results!.length)
        return null;

    if (info !== null) {
        const idType = info.schema!.getArgType('id');

        if (!idType || !idType.equals(resultType))
            return null;

        const resultInfo = ctx.resultInfo!;
        if (resultInfo.projection !== null) {
            // check that all projected names are present
            for (const name of resultInfo.projection) {
                if (!info.has(name))
                    return null;
            }
        }

        // check that the filter uses the right set of parameters
        for (const result of results) {
            if (!isInfoPhraseCompatibleWithResult(result, info))
                return null;
        }
    } else {
        if (ctx.resultInfo!.projection !== null)
            return null;
    }


    const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;
    return [results, info, action, hasLearnMore];
}

export type ThingpediaListProposal = [ContextInfo, SlotBag];

export function checkThingpediaListProposal(proposal : ThingpediaListProposal, additionalInfo : SlotBag|null) : ListProposal|null {
    const [ctx, info] = proposal;

    const resultInfo = ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!info.has(name))
                return null;
        }
    }

    let mergedInfo : SlotBag|null = info;
    if (additionalInfo) {
        // check that the new info is truthful
        for (const result of ctx.results!) {
            if (!isInfoPhraseCompatibleWithResult(result, additionalInfo))
                return null;
        }

        mergedInfo = SlotBag.merge(mergedInfo, additionalInfo);
    }
    if (!mergedInfo)
        return null;

    const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;
    return [ctx.results!, mergedInfo, action, false];
}

export function addActionToListProposal(nameList : NameList, action : Ast.Invocation) : ListProposal|null {
    const { ctx, results } = nameList;
    if (ctx.resultInfo!.projection !== null)
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if (last instanceof Ast.SliceExpression &&
        results.length !== ctx.results!.length)
        return null;

    const resultType = results[0].value.id.getType();
    if (!C.hasArgumentOfType(action, resultType))
        return null;
    const ctxAction = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;
    if (ctxAction && !C.isSameFunction(ctxAction.schema!, action.schema!))
        return null;

    return [results, null, action, false];
}

export function makeListProposalFromDirectAnswers(...phrases : DirectAnswerPhrase[]) : ListProposal|null {
    for (let i = 0; i < phrases.length; i++) {
        if (phrases[i].index !== i)
            return null;
    }

    const ctx = phrases[0].result.ctx;

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const last = currentTable.last;
    if ((last instanceof Ast.SliceExpression ||
        (last instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression)) &&
        phrases.length !== ctx.results!.length)
        return null;

    const names = Array.from(phrases[0].result.info.keys());
    // check that all phrases talk about the same slots (it would be weird otherwise)
    for (let i = 0; i < phrases.length; i++) {
        for (const key of phrases[i].result.info.keys()) {
            if (!names.includes(key))
                return null;
        }
        for (const name of names) {
            if (!phrases[i].result.info.has(name))
                return null;
        }
    }

    const resultInfo = ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const phrase of phrases) {
            for (const name of resultInfo.projection) {
                if (!phrase.result.info.has(name))
                    return null;
            }
        }
    }

    // don't use a direct answer with a list if the user is issuing a query by name
    const filterTable = C.findFilterExpression(currentTable);
    if (filterTable && C.filterUsesParam(filterTable.filter, 'id'))
        return null;

    const results = ctx.results!.slice(0, phrases.length);

    return [results, null, null, false];
}

function makeListProposalReply(ctx : ContextInfo, proposal : ListProposal) {
    const [results, /*info*/, action, hasLearnMore] = proposal;
    const options : AgentReplyOptions = {
        numResults: results.length
    };
    if (action || hasLearnMore)
        options.end = false;
    let dialogueAct;
    switch (results.length) {
    case 2:
        dialogueAct = 'sys_recommend_two';
        break;
    case 3:
        dialogueAct = 'sys_recommend_three';
        break;
    case 4:
        dialogueAct = 'sys_recommend_four';
        break;
    default:
        dialogueAct = 'sys_recommend_many';
    }
    if (action === null)
        return makeAgentReply(ctx, makeSimpleState(ctx, dialogueAct, null), proposal, null, options);
    else
        return makeAgentReply(ctx, addAction(ctx, dialogueAct, action, 'proposed'), proposal, null, options);
}

function positiveListProposalReply(loader : ThingpediaLoader,
                                   ctx : ContextInfo,
                                   [name, acceptedAction, mustHaveAction] : [Ast.Value, Ast.Invocation|null, boolean]) {
    // if actionProposal === null the flow is roughly
    //
    // U: hello i am looking for a restaurant
    // A: how about the ... or the ... ?
    // U: I like the ... bla
    //
    // in this case, the agent should hit the "... is a ... restaurant in the ..."
    // we treat it as "execute" dialogue act and add a filter that causes the program to return a single result

    const proposal = ctx.aux as ListProposal;
    const [results, /*info*/, actionProposal] = proposal;
    let good = false;
    for (const result of results) {
        if (result.value.id.equals(name)) {
            good = true;
            break;
        }
    }
    if (!good)
        return null;

    if (acceptedAction === null)
        acceptedAction = actionProposal;

    if (acceptedAction === null) {
        if (mustHaveAction)
            return null;

        const currentStmt = ctx.current!.stmt;
        const currentTable = currentStmt.expression;
        const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
        const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);
        if (newTable === null)
            return null;

        return addQuery(ctx, 'execute', newTable, 'accepted');
    } else {
        if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))
            return null;

        // do not consider a phrase of the form "play X" to be "accepting the action by name"
        // if the action auto-confirms, because the user is likely playing something else
        if (acceptedAction && name) {
            const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);
            if (confirm === 'auto')
                return null;
        }

        const chainParam = findChainParam(results[0], acceptedAction);
        if (!chainParam)
            return null;
        return addActionParam(ctx, 'execute', acceptedAction, chainParam, name, 'accepted');
    }
}

function positiveListProposalReplyActionByName(loader : ThingpediaLoader,
                                               ctx : ContextInfo,
                                               action : Ast.Invocation) {
    const proposal = ctx.aux;
    const [results,] = proposal;

    let name = null;
    const acceptedAction = action.clone();
    const idType = results[0].value.id.getType();
    // find the chain parameter for the action, extract the name, and set the param to undefined
    // as the rest of the code expects
    for (const in_param of acceptedAction.in_params) {
        const arg = action.schema!.getArgument(in_param.name);
        assert(arg);
        if (arg.type.equals(idType)) {
            name = in_param.value;
            in_param.value = new Ast.Value.Undefined(true);
            break;
        }
    }
    if (!name)
        return null;
    return positiveListProposalReply(loader, ctx, [name, acceptedAction, false]);
}

function negativeListProposalReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression|null, Ast.Expression|null]) {
    if (!((preamble === null || preamble instanceof Ast.FilterExpression) &&
          (request === null || request instanceof Ast.FilterExpression)))
        return null;

    const proposal = ctx.aux as ListProposal;
    const [results, info] = proposal;
    const proposalType = results[0].value.id.getType();
    request = combinePreambleAndRequest(preamble, request, info, proposalType);
    if (request === null)
        return null;
    return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);
}

function listProposalLearnMoreReply(ctx : ContextInfo, name : Ast.Value) {
    // note: a learn more from a list proposal is different than a learn_more from a recommendation
    // in a recommendation, there is no change to the program, and the agent replies "what would
    // you like to know"
    // in a list proposal, we add a filter "id == "

    const proposal = ctx.aux as ListProposal;
    const [results,] = proposal;
    let good = false;
    for (const result of results) {
        if (result.value.id.equals(name)) {
            good = true;
            break;
        }
    }
    if (!good)
        return null;

    const currentStmt = ctx.current!.stmt;
    const currentTable = currentStmt.expression;
    const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);
    const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);
    if (newTable === null)
        return null;

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

export {
    checkListProposal,
    makeListProposalReply,

    positiveListProposalReply,
    positiveListProposalReplyActionByName,
    listProposalLearnMoreReply,
    negativeListProposalReply
};

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';	5✔
23
24	import { Ast, } from 'thingtalk';	5✔
25
26	import * as C from '../ast_manip';	5✔
27	import ThingpediaLoader from '../load-thingpedia';
28
29	import {	5✔
30	AgentReplyOptions,
31	ContextInfo,
32	NameList,
33	makeAgentReply,
34	makeSimpleState,
35	addActionParam,
36	addAction,
37	addQuery,
38	} from '../state_manip';
39	import {	5✔
40	isInfoPhraseCompatibleWithResult,
41	findChainParam
42	} from './common';
43	import {	5✔
44	queryRefinement,
45	refineFilterToAnswerQuestionOrChangeFilter,
46	combinePreambleAndRequest,
47	proposalReply,
48	} from './refinement-helpers';
49	import {	5✔
50	SlotBag
51	} from '../slot_bag';
52	import {
53	DirectAnswerPhrase
54	} from './results';
55
56	export type ListProposal = [Ast.DialogueHistoryResultItem[], SlotBag\|null, Ast.Invocation\|null, boolean];
57
58	export function listProposalKeyFn([results, info, action, hasLearnMore] : ListProposal) {	5✔
59	return {	5,652✔
60	idType: results[0].value.id ? results[0].value.id.getType() : null,	5,652!
61	queryName: info ? info.schema!.qualifiedName : null,	5,652✔
62	actionName: action ? action.schema!.qualifiedName : null,	5,652✔
63	};
64	}
65
66	function checkListProposal(nameList : NameList, info : SlotBag\|null, hasLearnMore : boolean) : ListProposal\|null {
67	const { ctx, results } = nameList;	9,100✔
68	const resultType = results[0].value.id.getType();	9,100✔
69
70	const currentStmt = ctx.current!.stmt;	9,100✔
71	const currentTable = currentStmt.expression;	9,100✔
72	const last = currentTable.last;	9,100✔
73	if ((last instanceof Ast.SliceExpression \|\|	9,100✔
74	(last instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression)) &&
75	results.length !== ctx.results!.length)
76	return null;	9✔
77
78	if (info !== null) {	9,091✔
79	const idType = info.schema!.getArgType('id');	8,017✔
80
81	if (!idType \|\| !idType.equals(resultType))	8,017!
82	return null;	×
83
84	const resultInfo = ctx.resultInfo!;	8,017✔
85	if (resultInfo.projection !== null) {	8,017✔
86	// check that all projected names are present
87	for (const name of resultInfo.projection) {	225✔
88	if (!info.has(name))	225!
89	return null;	×
90	}
91	}
92
93	// check that the filter uses the right set of parameters
94	for (const result of results) {	8,017✔
95	if (!isInfoPhraseCompatibleWithResult(result, info))	19,460✔
96	return null;	6,605✔
97	}
98	} else {
99	if (ctx.resultInfo!.projection !== null)	1,074✔
100	return null;	140✔
101	}
102
103
104	const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	2,346✔
105	return [results, info, action, hasLearnMore];	2,346✔
106	}
107
108	export type ThingpediaListProposal = [ContextInfo, SlotBag];
109
110	export function checkThingpediaListProposal(proposal : ThingpediaListProposal, additionalInfo : SlotBag\|null) : ListProposal\|null {	5✔
111	const [ctx, info] = proposal;	×
112
113	const resultInfo = ctx.resultInfo!;	×
114	if (resultInfo.projection !== null) {	×
115	// check that all projected names are present
116	for (const name of resultInfo.projection) {	×
117	if (!info.has(name))	×
118	return null;	×
119	}
120	}
121
122	let mergedInfo : SlotBag\|null = info;	×
123	if (additionalInfo) {	×
124	// check that the new info is truthful
125	for (const result of ctx.results!) {	×
126	if (!isInfoPhraseCompatibleWithResult(result, additionalInfo))	×
127	return null;	×
128	}
129
130	mergedInfo = SlotBag.merge(mergedInfo, additionalInfo);	×
131	}
132	if (!mergedInfo)	×
133	return null;	×
134
135	const action = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	×
136	return [ctx.results!, mergedInfo, action, false];	×
137	}
138
139	export function addActionToListProposal(nameList : NameList, action : Ast.Invocation) : ListProposal\|null {	5✔
140	const { ctx, results } = nameList;	13,345✔
141	if (ctx.resultInfo!.projection !== null)	13,345✔
142	return null;	2,145✔
143
144	const currentStmt = ctx.current!.stmt;	11,200✔
145	const currentTable = currentStmt.expression;	11,200✔
146	const last = currentTable.last;	11,200✔
147	if (last instanceof Ast.SliceExpression &&	11,200!
148	results.length !== ctx.results!.length)
UNCOV 149	return null;	×
150
151	const resultType = results[0].value.id.getType();	11,200✔
152	if (!C.hasArgumentOfType(action, resultType))	11,200✔
153	return null;	8,300✔
154	const ctxAction = ctx.nextInfo && ctx.nextInfo.isAction ? C.getInvocation(ctx.next!) : null;	2,900✔
155	if (ctxAction && !C.isSameFunction(ctxAction.schema!, action.schema!))	2,900!
156	return null;	×
157
158	return [results, null, action, false];	2,900✔
159	}
160
161	export function makeListProposalFromDirectAnswers(...phrases : DirectAnswerPhrase[]) : ListProposal\|null {	5✔
162	for (let i = 0; i < phrases.length; i++) {	406✔
163	if (phrases[i].index !== i)	1,015!
164	return null;	×
165	}
166
167	const ctx = phrases[0].result.ctx;	406✔
168
169	const currentStmt = ctx.current!.stmt;	406✔
170	const currentTable = currentStmt.expression;	406✔
171	const last = currentTable.last;	406✔
172	if ((last instanceof Ast.SliceExpression \|\|	406!
173	(last instanceof Ast.ProjectionExpression && last.expression instanceof Ast.SliceExpression)) &&
174	phrases.length !== ctx.results!.length)
175	return null;	×
176
177	const names = Array.from(phrases[0].result.info.keys());	406✔
178	// check that all phrases talk about the same slots (it would be weird otherwise)
179	for (let i = 0; i < phrases.length; i++) {	406✔
180	for (const key of phrases[i].result.info.keys()) {	1,015✔
181	if (!names.includes(key))	1,015!
182	return null;	×
183	}
184	for (const name of names) {	1,015✔
185	if (!phrases[i].result.info.has(name))	1,015!
186	return null;	×
187	}
188	}
189
190	const resultInfo = ctx.resultInfo!;	406✔
191	if (resultInfo.projection !== null) {	406!
192	// check that all projected names are present
193	for (const phrase of phrases) {	406✔
194	for (const name of resultInfo.projection) {	1,015✔
195	if (!phrase.result.info.has(name))	1,015!
196	return null;	×
197	}
198	}
199	}
200
201	// don't use a direct answer with a list if the user is issuing a query by name
202	const filterTable = C.findFilterExpression(currentTable);	406✔
203	if (filterTable && C.filterUsesParam(filterTable.filter, 'id'))	406!
204	return null;	×
205
206	const results = ctx.results!.slice(0, phrases.length);	406✔
207
208	return [results, null, null, false];	406✔
209	}
210
211	function makeListProposalReply(ctx : ContextInfo, proposal : ListProposal) {
212	const [results, /info/, action, hasLearnMore] = proposal;	15,307✔
213	const options : AgentReplyOptions = {	15,307✔
214	numResults: results.length
215	};
216	if (action \|\| hasLearnMore)	15,307✔
217	options.end = false;	10,745✔
218	let dialogueAct;
219	switch (results.length) {	15,307✔
220	case 2:	15,307✔
221	dialogueAct = 'sys_recommend_two';	5,854✔
222	break;	5,854✔
223	case 3:
224	dialogueAct = 'sys_recommend_three';	4,828✔
225	break;	4,828✔
226	case 4:
227	dialogueAct = 'sys_recommend_four';	304✔
228	break;	304✔
229	default:
230	dialogueAct = 'sys_recommend_many';	4,321✔
231	}
232	if (action === null)	15,307✔
233	return makeAgentReply(ctx, makeSimpleState(ctx, dialogueAct, null), proposal, null, options);	5,044✔
234	else
235	return makeAgentReply(ctx, addAction(ctx, dialogueAct, action, 'proposed'), proposal, null, options);	10,263✔
236	}
237
238	function positiveListProposalReply(loader : ThingpediaLoader,
239	ctx : ContextInfo,
240	[name, acceptedAction, mustHaveAction] : [Ast.Value, Ast.Invocation\|null, boolean]) {
241	// if actionProposal === null the flow is roughly
242	//
243	// U: hello i am looking for a restaurant
244	// A: how about the ... or the ... ?
245	// U: I like the ... bla
246	//
247	// in this case, the agent should hit the "... is a ... restaurant in the ..."
248	// we treat it as "execute" dialogue act and add a filter that causes the program to return a single result
249
250	const proposal = ctx.aux as ListProposal;	591,968✔
251	const [results, /info/, actionProposal] = proposal;	591,968✔
252	let good = false;	591,968✔
253	for (const result of results) {	591,968✔
254	if (result.value.id.equals(name)) {	2,212,314✔
255	good = true;	7,372✔
256	break;	7,372✔
257	}
258	}
259	if (!good)	591,968✔
260	return null;	584,596✔
261
262	if (acceptedAction === null)	7,372✔
263	acceptedAction = actionProposal;	7,241✔
264
265	if (acceptedAction === null) {	7,372✔
266	if (mustHaveAction)	3,128✔
267	return null;	865✔
268
269	const currentStmt = ctx.current!.stmt;	2,263✔
270	const currentTable = currentStmt.expression;	2,263✔
271	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	2,263✔
272	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);	2,263✔
273	if (newTable === null)	2,263!
274	return null;	×
275
276	return addQuery(ctx, 'execute', newTable, 'accepted');	2,263✔
277	} else {
278	if (actionProposal !== null && !C.isSameFunction(actionProposal.schema!, acceptedAction.schema!))	4,244!
279	return null;	×
280
281	// do not consider a phrase of the form "play X" to be "accepting the action by name"
282	// if the action auto-confirms, because the user is likely playing something else
283	if (acceptedAction && name) {	4,244!
284	const confirm = loader.ttUtils.normalizeConfirmAnnotation(acceptedAction.schema as Ast.FunctionDef);	4,244✔
285	if (confirm === 'auto')	4,244!
286	return null;	4,244✔
287	}
288
289	const chainParam = findChainParam(results[0], acceptedAction);	×
290	if (!chainParam)	×
291	return null;	×
292	return addActionParam(ctx, 'execute', acceptedAction, chainParam, name, 'accepted');	×
293	}
294	}
295
296	function positiveListProposalReplyActionByName(loader : ThingpediaLoader,
297	ctx : ContextInfo,
298	action : Ast.Invocation) {
299	const proposal = ctx.aux;	13,144✔
300	const [results,] = proposal;	13,144✔
301
302	let name = null;	13,144✔
303	const acceptedAction = action.clone();	13,144✔
304	const idType = results[0].value.id.getType();	13,144✔
305	// find the chain parameter for the action, extract the name, and set the param to undefined
306	// as the rest of the code expects
307	for (const in_param of acceptedAction.in_params) {	13,144✔
308	const arg = action.schema!.getArgument(in_param.name);	19,516✔
309	assert(arg);	19,516✔
310	if (arg.type.equals(idType)) {	19,516✔
311	name = in_param.value;	2,253✔
312	in_param.value = new Ast.Value.Undefined(true);	2,253✔
313	break;	2,253✔
314	}
315	}
316	if (!name)	13,144✔
317	return null;	10,891✔
318	return positiveListProposalReply(loader, ctx, [name, acceptedAction, false]);	2,253✔
319	}
320
321	function negativeListProposalReply(ctx : ContextInfo, [preamble, request] : [Ast.Expression\|null, Ast.Expression\|null]) {
322	if (!((preamble === null \|\| preamble instanceof Ast.FilterExpression) &&	53,954!
323	(request === null \|\| request instanceof Ast.FilterExpression)))
324	return null;	×
325
326	const proposal = ctx.aux as ListProposal;	53,954✔
327	const [results, info] = proposal;	53,954✔
328	const proposalType = results[0].value.id.getType();	53,954✔
329	request = combinePreambleAndRequest(preamble, request, info, proposalType);	53,954✔
330	if (request === null)	53,954✔
331	return null;	43,475✔
332	return proposalReply(ctx, request, refineFilterToAnswerQuestionOrChangeFilter);	10,479✔
333	}
334
335	function listProposalLearnMoreReply(ctx : ContextInfo, name : Ast.Value) {
336	// note: a learn more from a list proposal is different than a learn_more from a recommendation
337	// in a recommendation, there is no change to the program, and the agent replies "what would
338	// you like to know"
339	// in a list proposal, we add a filter "id == "
340
341	const proposal = ctx.aux as ListProposal;	368,810✔
342	const [results,] = proposal;	368,810✔
343	let good = false;	368,810✔
344	for (const result of results) {	368,810✔
345	if (result.value.id.equals(name)) {	1,313,569✔
346	good = true;	9,254✔
347	break;	9,254✔
348	}
349	}
350	if (!good)	368,810✔
351	return null;	359,556✔
352
353	const currentStmt = ctx.current!.stmt;	9,254✔
354	const currentTable = currentStmt.expression;	9,254✔
355	const namefilter = new Ast.BooleanExpression.Atom(null, 'id', '==', name);	9,254✔
356	const newTable = queryRefinement(currentTable, namefilter, (one, two) => new Ast.BooleanExpression.And(null, [one, two]), null);	9,254✔
357	if (newTable === null)	9,254!
358	return null;	×
359
360	return addQuery(ctx, 'execute', newTable, 'accepted');	9,254✔
361	}
362
363	export {
364	checkListProposal,	5✔
365	makeListProposalReply,	5✔
366
367	positiveListProposalReply,	5✔
368	positiveListProposalReplyActionByName,	5✔
369	listProposalLearnMoreReply,	5✔
370	negativeListProposalReply	5✔
371	};

stanford-oval / genie-toolkit / 1903

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