1082

pending completion

Build # 1082

Build Type

Pull #248

travis-ci-com

Committed by

web-flow

Commit Message

Merge 5d0007e99 into 6245195ee

Pull Request Pull Request #248: Prototype for evaluate-by-device

Run Details

6749 of 12278 branches covered (54.97%)

Branch coverage included in aggregate %.

76 of 96 new or added lines in 3 files covered. (79.17%)

13 existing lines in 6 files now uncovered.

15406 of 23834 relevant lines covered (64.64%)

2867199.32 hits per line

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

91.13

/languages/thingtalk/dialogue_acts/refinement-helpers.js

// -*- mode: js; 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>
"use strict";

const assert = require('assert');

const ThingTalk = require('thingtalk');
const Ast = ThingTalk.Ast;

const C = require('../ast_manip');

const {
    addQuery
} = require('../state_manip');
const {
    isFilterCompatibleWithInfo,
    isSimpleFilterTable
} = require('./common');

/**
 * Find the filter table in the context.
 *
 * Like findFilterTable, but if we don't have one, make it up right before the invocation.
 *
 * Returns [root, filterTable]
 */
function findOrMakeFilterTable(root) {
    let table = root;
    let holder = null;
    while (!table.isFilter) {
        if (table.isSequence ||
            table.isHistory ||
            table.isWindow ||
            table.isTimeSeries)
            throw new Error('NOT IMPLEMENTED');

        // do not touch these with filters
        if (table.isAggregation ||
            table.isVarRef ||
            table.isResultRef)
            return [null, null];

        // go inside these
        if (table.isSort ||
            table.isIndex ||
            table.isSlice ||
            table.isProjection ||
            table.isCompute ||
            table.isAlias) {
            holder = table;
            table = table.table;
            continue;
        }

        if (table.isJoin) {
            holder = table;
            // go right on join, always
            table = table.rhs;
            continue;
        }

        assert(table.isInvocation);
        // if we get here, there is no filter table at all
        // make up one
        const newFilterTable = new Ast.Table.Filter(null, table, Ast.BooleanExpression.True, table.schema);
        if (holder === null) {
            assert(table === root);
            return [newFilterTable, newFilterTable];
        } else if (holder.isJoin) {
            holder.rhs = newFilterTable;
            return [root, newFilterTable];
        } else {
            holder.table = newFilterTable;
            return [root, newFilterTable];
        }
    }

    return [root, table];
}


function setsIntersect(s1, s2) {
    for (let el of s1) {
        if (s2.has(el))
            return true;
    }
    return false;
}


function neutralizeIDFilter(ast) {
    // clone a filter and replace "id == ..." atoms with "true"

    if (ast.isNot)
        return new Ast.BooleanExpression.Not(null, neutralizeIDFilter(ast.expr));
    if (ast.isOr)
        return new Ast.BooleanExpression.Or(null, ast.operands.map(neutralizeIDFilter));
    if (ast.isAnd)
        return new Ast.BooleanExpression.And(null, ast.operands.map(neutralizeIDFilter));
    if (ast.isTrue || ast.isDontCare || ast.isFalse || ast.isCompute || ast.isExternal)
        return ast;

    assert(ast.isAtom);
    if (ast.name === 'id' && ast.operator === '==')
        return Ast.BooleanExpression.True;
    return ast;
}


function filterToNegatedSlots(filter) {
    filter = filter.optimize();
    let operands, slots = {};
    if (filter.isAnd)
        operands = filter.operands;
    else
        operands = [filter];

    for (let operand of operands) {
        if (!operand.isNot)
            continue;
        let atom = operand.expr;
        if (!atom.isAtom && !atom.isDontCare)
            continue;

        slots[atom.name] = operand;
    }

    return slots;
}

function filterToSlots(filter) {
    filter = filter.optimize();
    let operands, slots = {};
    if (filter.isAnd)
        operands = filter.operands;
    else
        operands = [filter];

    for (let operand of operands) {
        if (!operand.isAtom && !operand.isDontCare)
            continue;

        slots[operand.name] = operand;
    }

    return slots;
}

function queryRefinement(ctxTable, newFilter, refineFilter, newProjection) {
    let cloneTable = ctxTable.clone();

    let refinedFilter;
    if (newFilter !== null) {
        let filterTable;
        [cloneTable, filterTable] = findOrMakeFilterTable(cloneTable);
        //if (ctxFilterTable === null)
        //    return null;
        assert(filterTable.isFilter);

        // TODO we need to push down the filter, if possible
        if (!isSimpleFilterTable(filterTable))
            return null;

        refinedFilter = refineFilter(filterTable.filter, newFilter);
        if (refinedFilter === null)
            return null;

        filterTable.filter = refinedFilter;
    }

    if (newProjection) {
        // if we have a new projection, we remove the projection entirely and replace it
        // with the new one

        if (cloneTable.isProjection)
            cloneTable = cloneTable.table;
        // there should be no projection of projection (will be optimized)
        assert(!cloneTable.isProjection);
        cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,
            C.resolveProjection(newProjection, cloneTable.schema));
    } else {
        // otherwise, we remove all fields from the projection that were mentioned in the
        // filter

        let oldProjection;
        if (cloneTable.isProjection) {
            oldProjection = cloneTable.args;
            cloneTable = cloneTable.table;
        }
        // there should be no projection of projection (will be optimized)
        assert(!cloneTable.isProjection);

        if (oldProjection) {
            if (newFilter !== null)
                newProjection = oldProjection.filter((pname) => !C.filterUsesParam(refinedFilter, pname));

            // if the projection is now empty, we don't add
            // the projection will be empty if
            // 1. the user asks a question
            // 2. the agent answers that question
            // 3. the user now refines the search indicating they don't like that answer
            //
            // on the other hand, if
            // 1. the user asks a question (eg. asks for "address")
            // 2. the agent answers that question
            // 3. the user now refines the search changing a different parameter
            // we will keep the projection

            if (newProjection.length > 0) {
                cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,
                    C.resolveProjection(newProjection, cloneTable.schema));
            }
        }
    }

    return cloneTable;
}


function refineFilterToAnswerQuestion(ctxFilter, refinedFilter) {
    // this function is used when:
    // - the agent asks a search refinement question, and the user answers it
    // - the agent proposes something to refine the question
    //
    // the refinement is allowed only if the parameter was not mentioned before
    // furthermore, "id ==" filters are removed from the refined filter, so a user
    // can choose a restaurant for a while then change their mind

    function getParamsInFilter(filter) {
        let params = new Set;
        filter.visit(new class extends Ast.NodeVisitor {
            visitAtomBooleanExpression(atom) {
                if (atom.name === 'id' && atom.operator === '==')
                    return false;
                params.add(atom.name);
                return false;
            }
            visitDontCareBooleanExpression(atom) {
                params.add(atom.name);
                return false;
            }
            visitExternalBooleanExpression() {
                return false;
            }
        });
        return params;
    }
    if (setsIntersect(getParamsInFilter(ctxFilter),  getParamsInFilter(refinedFilter)))
        return null;

    const clone = neutralizeIDFilter(ctxFilter);
    return new Ast.BooleanExpression.And(null, [clone, refinedFilter]).optimize();
}


function refineFilterToAnswerQuestionOrChangeFilter(ctxFilter, refinedFilter) {
    // this function is used:
    // - the agent proposes something, and the user replies with a bunch of filters
    //   (e.g. "how about terun?" "nah i'm looking for something chinese")
    //
    // the refinement is allowed only if the parameter was not mentioned before
    // at most one parameter can be mentioned in the context, in which case it must be different
    //
    // the refinement contains all clauses which are not explicitly negated in the refinement,
    // plus all of the refinement
    // furthermore, "id ==" filters are removed from the refined filter, so a user
    // can choose a restaurant for a while then change their mind

    ctxFilter = ctxFilter.optimize();
    refinedFilter = refinedFilter.optimize();

    const ctxSlots = filterToSlots(ctxFilter);
    const refinedSlots = filterToSlots(refinedFilter);
    const negatedRefinedSlots = filterToNegatedSlots(refinedFilter);

    let changedParam = undefined;
    // slots in the context must not mentioned in the refinement, except at most one can, and
    // it must be different operator or value
    //
    // note that both positive and negative filters are killed by this check
    // so neither "I want X food" nor "I don't like X food" are acceptable when "food =~ X" was
    // already in the context
    for (let key in ctxSlots) {
        assert(ctxSlots[key].isAtom || ctxSlots[key].isDontCare);
        if (negatedRefinedSlots[key])
            return null;
        if (refinedSlots[key]) {
            // dont change opinion from a dontcare to a not dontcare
            if (ctxSlots[key].isDontCare)
                return null;

            if (refinedSlots[key].equals(ctxSlots[key]))
                return null;
            if (changedParam !== undefined)
                return null;
            changedParam = key;
        }
    }

    const newCtxClauses = [];
    for (let clause of (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter])) {
        if (clause.isAtom || clause.isDontCare) {
            if (refinedSlots[clause.name])
                continue;
        }
        newCtxClauses.push(neutralizeIDFilter(clause));
    }

    return new Ast.BooleanExpression.And(null, [...newCtxClauses, refinedFilter]).optimize();
}


function refineFilterToChangeFilter(ctxFilter, refinedFilter) {
    // this function is used:
    // - when the agent returned zero results, and the user
    //   must change the search
    // - when the agent makes a filter proposal, and the user says no I want something else
    //
    // the refinement is allowed only if no new parameters are introduced (all parameters were
    // mentioned before), and at least one parameter is different than before
    //
    // the resulting filter uses all the parameters in ctxFilter that are not mentioned
    // in refinedFilter, as well as all of refinedFilter

    ctxFilter = ctxFilter.optimize();
    refinedFilter = refinedFilter.optimize();

    const ctxSlots = filterToSlots(ctxFilter);
    const refinedSlots = filterToSlots(refinedFilter);
    // all slots in the context must be either not mentioned in the refinement, or changed
    for (let key in ctxSlots) {
        if (refinedSlots[key] && refinedSlots[key].equals(ctxSlots[key]))
            return null;
    }
    // all slots that are in the refinement must be mentioned in the context
    for (let key in refinedSlots) {
        if (!ctxSlots[key])
            return null;
    }

    const ctxClauses = (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter]).filter((clause) => {
        let good = true;
        clause.visit(new class extends Ast.NodeVisitor {
             visitExternalBooleanExpression() {
                // do not recurse
                // get rid of get-predicates in the context, regardless
                good = false;
                return false;
            }
            visitValue() {
                // do not recurse
                return false;
            }

            visitAtomBooleanExpression(atom) {
                good = good && !C.filterUsesParam(refinedFilter, atom.name);
                return true;
            }
            visitDontCareBooleanExpression(atom) {
                good = good && !C.filterUsesParam(refinedFilter, atom.name);
                return true;
            }
        });
        return good;
    });

    return new Ast.BooleanExpression.And(null, [...ctxClauses, refinedFilter]).optimize();
}

/**
 * User act: in response to any proposal from the agent (refined query, recommendation, list
 * proposal), the user replies with a search.
 */
function proposalReply(ctx, request, refinementFunction) {
    if (!C.isSameFunction(ctx.currentFunctionSchema, request.schema))
        return null;

    // TODO we need to push down the filter, if possible
    if (!isSimpleFilterTable(request))
        return null;

    const currentTable = ctx.current.stmt.table;
    const newTable = queryRefinement(currentTable, request.filter, refinementFunction);
    if (newTable === null)
        return null;

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

function isValidNegativePreambleForInfo(info, preamble) {
    // the preamble must match the info provided
    // (and we will negate it later)
    return isFilterCompatibleWithInfo(info, preamble.filter);
}

function combinePreambleAndRequest(preamble, request, info, proposalType) {
    if (preamble !== null) {
        if (info === null || !isValidNegativePreambleForInfo(info, preamble))
            return null;
    }

    if (preamble !== null && request !== null) {
        if (!C.isSameFunction(preamble.schema, request.schema))
            return null;
        const refined = refineFilterToChangeFilter(preamble.filter, request.filter);
        if (refined === null)
            return null;

        // convert the preamble into a request by negating it, then add the new request
        request = new Ast.Table.Filter(null, request.table, new Ast.BooleanExpression.And(null, [
            new Ast.BooleanExpression.Not(null, preamble.filter),
            request.filter
        ]), request.schema);
    } else if (preamble !== null) {
        // convert the preamble into a request by negating it
        // shallow clone
        assert(preamble instanceof Ast.Table.Filter);
        request = new Ast.Table.Filter(null, preamble.table, preamble.filter, preamble.schema);
        request.filter = new Ast.BooleanExpression.Not(null, request.filter);
    }
    assert(request !== null);

    const idType = request.schema.getArgType('id');

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

    return request;
}

module.exports = {
    findOrMakeFilterTable,
    queryRefinement,
    refineFilterToAnswerQuestion,
    refineFilterToAnswerQuestionOrChangeFilter,
    refineFilterToChangeFilter,
    proposalReply,
    combinePreambleAndRequest
};

1	// -- mode: js; 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	"use strict";
21
22	const assert = require('assert');	3✔
23
24	const ThingTalk = require('thingtalk');	3✔
25	const Ast = ThingTalk.Ast;	3✔
26
27	const C = require('../ast_manip');	3✔
28
29	const {
30	addQuery
31	} = require('../state_manip');	3✔
32	const {
33	isFilterCompatibleWithInfo,
34	isSimpleFilterTable
35	} = require('./common');	3✔
36
37	/**
38	* Find the filter table in the context.
39	*
40	* Like findFilterTable, but if we don't have one, make it up right before the invocation.
41	*
42	* Returns [root, filterTable]
43	*/
44	function findOrMakeFilterTable(root) {
45	let table = root;	208,590✔
46	let holder = null;	208,590✔
47	while (!table.isFilter) {	208,590✔
48	if (table.isSequence \|\|	75,105!
49	table.isHistory \|\|
50	table.isWindow \|\|
51	table.isTimeSeries)
52	throw new Error('NOT IMPLEMENTED');	×
53
54	// do not touch these with filters
55	if (table.isAggregation \|\|	75,105!
56	table.isVarRef \|\|
57	table.isResultRef)
58	return [null, null];	×
59
60	// go inside these
61	if (table.isSort \|\|	75,105✔
62	table.isIndex \|\|
63	table.isSlice \|\|
64	table.isProjection \|\|
65	table.isCompute \|\|
66	table.isAlias) {
67	holder = table;	9,447✔
68	table = table.table;	9,447✔
69	continue;	9,447✔
70	}
71
72	if (table.isJoin) {	65,658!
73	holder = table;	×
74	// go right on join, always
75	table = table.rhs;	×
76	continue;	×
77	}
78
79	assert(table.isInvocation);	65,658✔
80	// if we get here, there is no filter table at all
81	// make up one
82	const newFilterTable = new Ast.Table.Filter(null, table, Ast.BooleanExpression.True, table.schema);	65,658✔
83	if (holder === null) {	65,658✔
84	assert(table === root);	64,418✔
85	return [newFilterTable, newFilterTable];	64,418✔
86	} else if (holder.isJoin) {	1,240!
87	holder.rhs = newFilterTable;	×
88	return [root, newFilterTable];	×
89	} else {
90	holder.table = newFilterTable;	1,240✔
91	return [root, newFilterTable];	1,240✔
92	}
93	}
94
95	return [root, table];	142,932✔
96	}
97
98
99	function setsIntersect(s1, s2) {
100	for (let el of s1) {	175,446✔
101	if (s2.has(el))	242,852✔
102	return true;	72,457✔
103	}
104	return false;	102,989✔
105	}
106
107
108	function neutralizeIDFilter(ast) {
109	// clone a filter and replace "id == ..." atoms with "true"
110
111	if (ast.isNot)	212,110!
112	return new Ast.BooleanExpression.Not(null, neutralizeIDFilter(ast.expr));	×
113	if (ast.isOr)	212,110!
114	return new Ast.BooleanExpression.Or(null, ast.operands.map(neutralizeIDFilter));	×
115	if (ast.isAnd)	212,110✔
116	return new Ast.BooleanExpression.And(null, ast.operands.map(neutralizeIDFilter));	47,024✔
117	if (ast.isTrue \|\| ast.isDontCare \|\| ast.isFalse \|\| ast.isCompute \|\| ast.isExternal)	165,086✔
118	return ast;	46,974✔
119
120	assert(ast.isAtom);	118,112✔
121	if (ast.name === 'id' && ast.operator === '==')	118,112✔
122	return Ast.BooleanExpression.True;	30✔
123	return ast;	118,082✔
124	}
125
126
127	function filterToNegatedSlots(filter) {
128	filter = filter.optimize();	12,631✔
129	let operands, slots = {};	12,631✔
130	if (filter.isAnd)	12,631✔
131	operands = filter.operands;	10,271✔
132	else
133	operands = [filter];	2,360✔
134
135	for (let operand of operands) {	12,631✔
136	if (!operand.isNot)	28,005✔
137	continue;	27,736✔
138	let atom = operand.expr;	269✔
139	if (!atom.isAtom && !atom.isDontCare)	269!
140	continue;	×
141
142	slots[atom.name] = operand;	269✔
143	}
144
145	return slots;	12,631✔
146	}
147
148	function filterToSlots(filter) {
149	filter = filter.optimize();	426,538✔
150	let operands, slots = {};	426,538✔
151	if (filter.isAnd)	426,538✔
152	operands = filter.operands;	218,087✔
153	else
154	operands = [filter];	208,451✔
155
156	for (let operand of operands) {	426,538✔
157	if (!operand.isAtom && !operand.isDontCare)	759,759✔
158	continue;	4,784✔
159
160	slots[operand.name] = operand;	754,975✔
161	}
162
163	return slots;	426,538✔
164	}
165
166	function queryRefinement(ctxTable, newFilter, refineFilter, newProjection) {
167	let cloneTable = ctxTable.clone();	136,912✔
168
169	let refinedFilter;
170	if (newFilter !== null) {	136,912✔
171	let filterTable;
172	[cloneTable, filterTable] = findOrMakeFilterTable(cloneTable);	136,212✔
173	//if (ctxFilterTable === null)
174	// return null;
175	assert(filterTable.isFilter);	136,212✔
176
177	// TODO we need to push down the filter, if possible
178	if (!isSimpleFilterTable(filterTable))	136,212!
179	return null;	×
180
181	refinedFilter = refineFilter(filterTable.filter, newFilter);	136,212✔
182	if (refinedFilter === null)	136,212✔
183	return null;	38,977✔
184
185	filterTable.filter = refinedFilter;	97,235✔
186	}
187
188	if (newProjection) {	97,935✔
189	// if we have a new projection, we remove the projection entirely and replace it
190	// with the new one
191
192	if (cloneTable.isProjection)	3,913✔
193	cloneTable = cloneTable.table;	24✔
194	// there should be no projection of projection (will be optimized)
195	assert(!cloneTable.isProjection);	3,913✔
196	cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,	3,913✔
197	C.resolveProjection(newProjection, cloneTable.schema));
198	} else {
199	// otherwise, we remove all fields from the projection that were mentioned in the
200	// filter
201
202	let oldProjection;
203	if (cloneTable.isProjection) {	94,022✔
204	oldProjection = cloneTable.args;	4,992✔
205	cloneTable = cloneTable.table;	4,992✔
206	}
207	// there should be no projection of projection (will be optimized)
208	assert(!cloneTable.isProjection);	94,022✔
209
210	if (oldProjection) {	94,022✔
211	if (newFilter !== null)	4,992!
212	newProjection = oldProjection.filter((pname) => !C.filterUsesParam(refinedFilter, pname));	7,033✔
213
214	// if the projection is now empty, we don't add
215	// the projection will be empty if
216	// 1. the user asks a question
217	// 2. the agent answers that question
218	// 3. the user now refines the search indicating they don't like that answer
219	//
220	// on the other hand, if
221	// 1. the user asks a question (eg. asks for "address")
222	// 2. the agent answers that question
223	// 3. the user now refines the search changing a different parameter
224	// we will keep the projection
225
226	if (newProjection.length > 0) {	4,992✔
227	cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,	3,226✔
228	C.resolveProjection(newProjection, cloneTable.schema));
229	}
230	}
231	}
232
233	return cloneTable;	97,935✔
234	}
235
236
237	function refineFilterToAnswerQuestion(ctxFilter, refinedFilter) {
238	// this function is used when:
239	// - the agent asks a search refinement question, and the user answers it
240	// - the agent proposes something to refine the question
241	//
242	// the refinement is allowed only if the parameter was not mentioned before
243	// furthermore, "id ==" filters are removed from the refined filter, so a user
244	// can choose a restaurant for a while then change their mind
245
246	function getParamsInFilter(filter) {
247	let params = new Set;	350,892✔
248	filter.visit(new class extends Ast.NodeVisitor {	350,892✔
249	visitAtomBooleanExpression(atom) {
250	if (atom.name === 'id' && atom.operator === '==')	458,209✔
251	return false;	3,237✔
252	params.add(atom.name);	454,972✔
253	return false;	454,972✔
254	}
255	visitDontCareBooleanExpression(atom) {
256	params.add(atom.name);	85,943✔
257	return false;	85,943✔
258	}
259	visitExternalBooleanExpression() {
260	return false;	×
261	}
262	});
263	return params;	350,892✔
264	}
265	if (setsIntersect(getParamsInFilter(ctxFilter), getParamsInFilter(refinedFilter)))	175,446✔
266	return null;	72,457✔
267
268	const clone = neutralizeIDFilter(ctxFilter);	102,989✔
269	return new Ast.BooleanExpression.And(null, [clone, refinedFilter]).optimize();	102,989✔
270	}
271
272
273	function refineFilterToAnswerQuestionOrChangeFilter(ctxFilter, refinedFilter) {
274	// this function is used:
275	// - the agent proposes something, and the user replies with a bunch of filters
276	// (e.g. "how about terun?" "nah i'm looking for something chinese")
277	//
278	// the refinement is allowed only if the parameter was not mentioned before
279	// at most one parameter can be mentioned in the context, in which case it must be different
280	//
281	// the refinement contains all clauses which are not explicitly negated in the refinement,
282	// plus all of the refinement
283	// furthermore, "id ==" filters are removed from the refined filter, so a user
284	// can choose a restaurant for a while then change their mind
285
286	ctxFilter = ctxFilter.optimize();	12,631✔
287	refinedFilter = refinedFilter.optimize();	12,631✔
288
289	const ctxSlots = filterToSlots(ctxFilter);	12,631✔
290	const refinedSlots = filterToSlots(refinedFilter);	12,631✔
291	const negatedRefinedSlots = filterToNegatedSlots(refinedFilter);	12,631✔
292
293	let changedParam = undefined;	12,631✔
294	// slots in the context must not mentioned in the refinement, except at most one can, and
295	// it must be different operator or value
296	//
297	// note that both positive and negative filters are killed by this check
298	// so neither "I want X food" nor "I don't like X food" are acceptable when "food =~ X" was
299	// already in the context
300	for (let key in ctxSlots) {	12,631✔
301	assert(ctxSlots[key].isAtom \|\| ctxSlots[key].isDontCare);	8,228✔
302	if (negatedRefinedSlots[key])	8,228✔
303	return null;	134✔
304	if (refinedSlots[key]) {	8,094✔
305	// dont change opinion from a dontcare to a not dontcare
306	if (ctxSlots[key].isDontCare)	4,201✔
307	return null;	16✔
308
309	if (refinedSlots[key].equals(ctxSlots[key]))	4,185✔
310	return null;	1,170✔
311	if (changedParam !== undefined)	3,015!
UNCOV 312	return null;	×
313	changedParam = key;	3,015✔
314	}
315	}
316
317	const newCtxClauses = [];	11,311✔
318	for (let clause of (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter])) {	11,311!
319	if (clause.isAtom \|\| clause.isDontCare) {	11,311✔
320	if (refinedSlots[clause.name])	6,908✔
321	continue;	3,015✔
322	}
323	newCtxClauses.push(neutralizeIDFilter(clause));	8,296✔
324	}
325
326	return new Ast.BooleanExpression.And(null, [...newCtxClauses, refinedFilter]).optimize();	11,311✔
327	}
328
329
330	function refineFilterToChangeFilter(ctxFilter, refinedFilter) {
331	// this function is used:
332	// - when the agent returned zero results, and the user
333	// must change the search
334	// - when the agent makes a filter proposal, and the user says no I want something else
335	//
336	// the refinement is allowed only if no new parameters are introduced (all parameters were
337	// mentioned before), and at least one parameter is different than before
338	//
339	// the resulting filter uses all the parameters in ctxFilter that are not mentioned
340	// in refinedFilter, as well as all of refinedFilter
341
342	ctxFilter = ctxFilter.optimize();	200,638✔
343	refinedFilter = refinedFilter.optimize();	200,638✔
344
345	const ctxSlots = filterToSlots(ctxFilter);	200,638✔
346	const refinedSlots = filterToSlots(refinedFilter);	200,638✔
347	// all slots in the context must be either not mentioned in the refinement, or changed
348	for (let key in ctxSlots) {	200,638✔
349	if (refinedSlots[key] && refinedSlots[key].equals(ctxSlots[key]))	386,119✔
350	return null;	10,121✔
351	}
352	// all slots that are in the refinement must be mentioned in the context
353	for (let key in refinedSlots) {	190,517✔
354	if (!ctxSlots[key])	244,108✔
355	return null;	137,524✔
356	}
357
358	const ctxClauses = (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter]).filter((clause) => {	52,993✔
359	let good = true;	120,749✔
360	clause.visit(new class extends Ast.NodeVisitor {	120,749✔
361	visitExternalBooleanExpression() {
362	// do not recurse
363	// get rid of get-predicates in the context, regardless
364	good = false;	×
365	return false;	×
366	}
367	visitValue() {
368	// do not recurse
369	return false;	118,860✔
370	}
371
372	visitAtomBooleanExpression(atom) {
373	good = good && !C.filterUsesParam(refinedFilter, atom.name);	118,860✔
374	return true;	118,860✔
375	}
376	visitDontCareBooleanExpression(atom) {
377	good = good && !C.filterUsesParam(refinedFilter, atom.name);	1,889✔
378	return true;	1,889✔
379	}
380	});
381	return good;	120,749✔
382	});
383
384	return new Ast.BooleanExpression.And(null, [...ctxClauses, refinedFilter]).optimize();	52,993✔
385	}
386
387	/**
388	* User act: in response to any proposal from the agent (refined query, recommendation, list
389	* proposal), the user replies with a search.
390	*/
391	function proposalReply(ctx, request, refinementFunction) {
392	if (!C.isSameFunction(ctx.currentFunctionSchema, request.schema))	37,091✔
393	return null;	3,783✔
394
395	// TODO we need to push down the filter, if possible
396	if (!isSimpleFilterTable(request))	33,308!
397	return null;	×
398
399	const currentTable = ctx.current.stmt.table;	33,308✔
400	const newTable = queryRefinement(currentTable, request.filter, refinementFunction);	33,308✔
401	if (newTable === null)	33,308✔
402	return null;	1,320✔
403
404	return addQuery(ctx, 'execute', newTable, 'accepted');	31,988✔
405	}
406
407	function isValidNegativePreambleForInfo(info, preamble) {
408	// the preamble must match the info provided
409	// (and we will negate it later)
410	return isFilterCompatibleWithInfo(info, preamble.filter);	173,110✔
411	}
412
413	function combinePreambleAndRequest(preamble, request, info, proposalType) {
414	if (preamble !== null) {	261,490✔
415	if (info === null \|\| !isValidNegativePreambleForInfo(info, preamble))	217,700✔
416	return null;	214,392✔
417	}
418
419	if (preamble !== null && request !== null) {	47,098✔
420	if (!C.isSameFunction(preamble.schema, request.schema))	3,205✔
421	return null;	1,659✔
422	const refined = refineFilterToChangeFilter(preamble.filter, request.filter);	1,546✔
423	if (refined === null)	1,546✔
424	return null;	1,347✔
425
426	// convert the preamble into a request by negating it, then add the new request
427	request = new Ast.Table.Filter(null, request.table, new Ast.BooleanExpression.And(null, [	199✔
428	new Ast.BooleanExpression.Not(null, preamble.filter),
429	request.filter
430	]), request.schema);
431	} else if (preamble !== null) {	43,893✔
432	// convert the preamble into a request by negating it
433	// shallow clone
434	assert(preamble instanceof Ast.Table.Filter);	103✔
435	request = new Ast.Table.Filter(null, preamble.table, preamble.filter, preamble.schema);	103✔
436	request.filter = new Ast.BooleanExpression.Not(null, request.filter);	103✔
437	}
438	assert(request !== null);	44,092✔
439
440	const idType = request.schema.getArgType('id');	44,092✔
441
442	if (!idType \|\| !idType.equals(proposalType))	44,092✔
443	return null;	31,461✔
444
445	return request;	12,631✔
446	}
447
448	module.exports = {	3✔
449	findOrMakeFilterTable,
450	queryRefinement,
451	refineFilterToAnswerQuestion,
452	refineFilterToAnswerQuestionOrChangeFilter,
453	refineFilterToChangeFilter,
454	proposalReply,
455	combinePreambleAndRequest
456	};

stanford-oval / genie-toolkit / 1082

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