1979

pending completion

Build # 1979

Build Type

Pull #614

travis-ci-com

Committed by

web-flow

Commit Message

Merge 3a6103c09 into f6d4307c1

Pull Request Pull Request #614: Update dependencies

Run Details

12262 of 25915 branches covered (47.32%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 5 files covered. (85.71%)

112 existing lines in 7 files now uncovered.

28531 of 48713 relevant lines covered (58.57%)

434519.78 hits per line

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

83.23

/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 interface ListProposal {
    results : Ast.DialogueHistoryResultItem[];
    info : SlotBag|null;
    action : Ast.Invocation|null;
    hasLearnMore : 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,
        length: results.length
    };
}

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 { results: ctx.results!, info: mergedInfo, action, hasLearnMore: 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, info: null, action, hasLearnMore: 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;

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

    const resultInfo = ctx.resultInfo!;
    if (resultInfo.projection !== null) {
        // check that all projected names are present
        for (const name of resultInfo.projection) {
            if (!phrases[0].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, info: null, action: null, hasLearnMore: false };
}

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

stanford-oval / genie-toolkit / 1979

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