1073

pending completion

Build # 1073

Build Type

Pull #244

travis-ci-com

Committed by

web-flow

Commit Message

Merge eab27b192 into f1ddda6ad

Pull Request Pull Request #244: Fixes to some Genie tool

Run Details

6748 of 12287 branches covered (54.92%)

Branch coverage included in aggregate %.

0 of 23 new or added lines in 2 files covered. (0.0%)

3 existing lines in 3 files now uncovered.

15394 of 23838 relevant lines covered (64.58%)

2816068.98 hits per line

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

91.44

/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,842✔
46	let holder = null;	208,842✔
47	while (!table.isFilter) {	208,842✔
48	if (table.isSequence \|\|	74,075!
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 \|\|	74,075!
56	table.isVarRef \|\|
57	table.isResultRef)
58	return [null, null];	×
59
60	// go inside these
61	if (table.isSort \|\|	74,075✔
62	table.isIndex \|\|
63	table.isSlice \|\|
64	table.isProjection \|\|
65	table.isCompute \|\|
66	table.isAlias) {
67	holder = table;	8,108✔
68	table = table.table;	8,108✔
69	continue;	8,108✔
70	}
71
72	if (table.isJoin) {	65,967!
73	holder = table;	×
74	// go right on join, always
75	table = table.rhs;	×
76	continue;	×
77	}
78
79	assert(table.isInvocation);	65,967✔
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,967✔
83	if (holder === null) {	65,967✔
84	assert(table === root);	64,727✔
85	return [newFilterTable, newFilterTable];	64,727✔
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,875✔
96	}
97
98
99	function setsIntersect(s1, s2) {
100	for (let el of s1) {	177,760✔
101	if (s2.has(el))	246,682✔
102	return true;	73,100✔
103	}
104	return false;	104,660✔
105	}
106
107
108	function neutralizeIDFilter(ast) {
109	// clone a filter and replace "id == ..." atoms with "true"
110
111	if (ast.isNot)	216,366!
112	return new Ast.BooleanExpression.Not(null, neutralizeIDFilter(ast.expr));	×
113	if (ast.isOr)	216,366!
114	return new Ast.BooleanExpression.Or(null, ast.operands.map(neutralizeIDFilter));	×
115	if (ast.isAnd)	216,366✔
116	return new Ast.BooleanExpression.And(null, ast.operands.map(neutralizeIDFilter));	48,299✔
117	if (ast.isTrue \|\| ast.isDontCare \|\| ast.isFalse \|\| ast.isCompute \|\| ast.isExternal)	168,067✔
118	return ast;	48,003✔
119
120	assert(ast.isAtom);	120,064✔
121	if (ast.name === 'id' && ast.operator === '==')	120,064✔
122	return Ast.BooleanExpression.True;	15✔
123	return ast;	120,049✔
124	}
125
126
127	function filterToNegatedSlots(filter) {
128	filter = filter.optimize();	11,844✔
129	let operands, slots = {};	11,844✔
130	if (filter.isAnd)	11,844✔
131	operands = filter.operands;	9,433✔
132	else
133	operands = [filter];	2,411✔
134
135	for (let operand of operands) {	11,844✔
136	if (!operand.isNot)	26,619✔
137	continue;	26,532✔
138	let atom = operand.expr;	87✔
139	if (!atom.isAtom && !atom.isDontCare)	87!
140	continue;	×
141
142	slots[atom.name] = operand;	87✔
143	}
144
145	return slots;	11,844✔
146	}
147
148	function filterToSlots(filter) {
149	filter = filter.optimize();	449,526✔
150	let operands, slots = {};	449,526✔
151	if (filter.isAnd)	449,526✔
152	operands = filter.operands;	237,624✔
153	else
154	operands = [filter];	211,902✔
155
156	for (let operand of operands) {	449,526✔
157	if (!operand.isAtom && !operand.isDontCare)	818,226✔
158	continue;	5,117✔
159
160	slots[operand.name] = operand;	813,109✔
161	}
162
163	return slots;	449,526✔
164	}
165
166	function queryRefinement(ctxTable, newFilter, refineFilter, newProjection) {
167	let cloneTable = ctxTable.clone();	137,116✔
168
169	let refinedFilter;
170	if (newFilter !== null) {	137,116✔
171	let filterTable;
172	[cloneTable, filterTable] = findOrMakeFilterTable(cloneTable);	136,464✔
173	//if (ctxFilterTable === null)
174	// return null;
175	assert(filterTable.isFilter);	136,464✔
176
177	// TODO we need to push down the filter, if possible
178	if (!isSimpleFilterTable(filterTable))	136,464!
179	return null;	×
180
181	refinedFilter = refineFilter(filterTable.filter, newFilter);	136,464✔
182	if (refinedFilter === null)	136,464✔
183	return null;	39,260✔
184
185	filterTable.filter = refinedFilter;	97,204✔
186	}
187
188	if (newProjection) {	97,856✔
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,503✔
193	cloneTable = cloneTable.table;	5✔
194	// there should be no projection of projection (will be optimized)
195	assert(!cloneTable.isProjection);	3,503✔
196	cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,	3,503✔
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,353✔
204	oldProjection = cloneTable.args;	4,552✔
205	cloneTable = cloneTable.table;	4,552✔
206	}
207	// there should be no projection of projection (will be optimized)
208	assert(!cloneTable.isProjection);	94,353✔
209
210	if (oldProjection) {	94,353✔
211	if (newFilter !== null)	4,552!
212	newProjection = oldProjection.filter((pname) => !C.filterUsesParam(refinedFilter, pname));	6,593✔
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,552✔
227	cloneTable = new Ast.Table.Projection(null, cloneTable, newProjection,	2,788✔
228	C.resolveProjection(newProjection, cloneTable.schema));
229	}
230	}
231	}
232
233	return cloneTable;	97,856✔
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;	355,520✔
248	filter.visit(new class extends Ast.NodeVisitor {	355,520✔
249	visitAtomBooleanExpression(atom) {
250	if (atom.name === 'id' && atom.operator === '==')	464,361✔
251	return false;	2,856✔
252	params.add(atom.name);	461,505✔
253	return false;	461,505✔
254	}
255	visitDontCareBooleanExpression(atom) {
256	params.add(atom.name);	87,158✔
257	return false;	87,158✔
258	}
259	visitExternalBooleanExpression() {
260	return false;	×
261	}
262	});
263	return params;	355,520✔
264	}
265	if (setsIntersect(getParamsInFilter(ctxFilter), getParamsInFilter(refinedFilter)))	177,760✔
266	return null;	73,100✔
267
268	const clone = neutralizeIDFilter(ctxFilter);	104,660✔
269	return new Ast.BooleanExpression.And(null, [clone, refinedFilter]).optimize();	104,660✔
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();	11,844✔
287	refinedFilter = refinedFilter.optimize();	11,844✔
288
289	const ctxSlots = filterToSlots(ctxFilter);	11,844✔
290	const refinedSlots = filterToSlots(refinedFilter);	11,844✔
291	const negatedRefinedSlots = filterToNegatedSlots(refinedFilter);	11,844✔
292
293	let changedParam = undefined;	11,844✔
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) {	11,844✔
301	assert(ctxSlots[key].isAtom \|\| ctxSlots[key].isDontCare);	8,300✔
302	if (negatedRefinedSlots[key])	8,300!
UNCOV 303	return null;	×
304	if (refinedSlots[key]) {	8,300✔
305	// dont change opinion from a dontcare to a not dontcare
306	if (ctxSlots[key].isDontCare)	4,868✔
307	return null;	517✔
308
309	if (refinedSlots[key].equals(ctxSlots[key]))	4,351✔
310	return null;	686✔
311	if (changedParam !== undefined)	3,665✔
312	return null;	651✔
313	changedParam = key;	3,014✔
314	}
315	}
316
317	const newCtxClauses = [];	9,990✔
318	for (let clause of (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter])) {	9,990✔
319	if (clause.isAtom \|\| clause.isDontCare) {	10,618✔
320	if (refinedSlots[clause.name])	5,700✔
321	continue;	2,287✔
322	}
323	newCtxClauses.push(neutralizeIDFilter(clause));	8,331✔
324	}
325
326	return new Ast.BooleanExpression.And(null, [...newCtxClauses, refinedFilter]).optimize();	9,990✔
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();	212,919✔
343	refinedFilter = refinedFilter.optimize();	212,919✔
344
345	const ctxSlots = filterToSlots(ctxFilter);	212,919✔
346	const refinedSlots = filterToSlots(refinedFilter);	212,919✔
347	// all slots in the context must be either not mentioned in the refinement, or changed
348	for (let key in ctxSlots) {	212,919✔
349	if (refinedSlots[key] && refinedSlots[key].equals(ctxSlots[key]))	411,474✔
350	return null;	11,007✔
351	}
352	// all slots that are in the refinement must be mentioned in the context
353	for (let key in refinedSlots) {	201,912✔
354	if (!ctxSlots[key])	262,310✔
355	return null;	148,252✔
356	}
357
358	const ctxClauses = (ctxFilter.isAnd ? ctxFilter.operands : [ctxFilter]).filter((clause) => {	53,660✔
359	let good = true;	121,774✔
360	clause.visit(new class extends Ast.NodeVisitor {	121,774✔
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;	119,883✔
370	}
371
372	visitAtomBooleanExpression(atom) {
373	good = good && !C.filterUsesParam(refinedFilter, atom.name);	119,883✔
374	return true;	119,883✔
375	}
376	visitDontCareBooleanExpression(atom) {
377	good = good && !C.filterUsesParam(refinedFilter, atom.name);	1,891✔
378	return true;	1,891✔
379	}
380	});
381	return good;	121,774✔
382	});
383
384	return new Ast.BooleanExpression.And(null, [...ctxClauses, refinedFilter]).optimize();	53,660✔
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,408✔
393	return null;	3,797✔
394
395	// TODO we need to push down the filter, if possible
396	if (!isSimpleFilterTable(request))	33,611!
397	return null;	×
398
399	const currentTable = ctx.current.stmt.table;	33,611✔
400	const newTable = queryRefinement(currentTable, request.filter, refinementFunction);	33,611✔
401	if (newTable === null)	33,611✔
402	return null;	1,854✔
403
404	return addQuery(ctx, 'execute', newTable, 'accepted');	31,757✔
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);	129,064✔
411	}
412
413	function combinePreambleAndRequest(preamble, request, info, proposalType) {
414	if (preamble !== null) {	252,684✔
415	if (info === null \|\| !isValidNegativePreambleForInfo(info, preamble))	208,800✔
416	return null;	207,371✔
417	}
418
419	if (preamble !== null && request !== null) {	45,313✔
420	if (!C.isSameFunction(preamble.schema, request.schema))	1,379✔
421	return null;	698✔
422	const refined = refineFilterToChangeFilter(preamble.filter, request.filter);	681✔
423	if (refined === null)	681✔
424	return null;	644✔
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, [	37✔
428	new Ast.BooleanExpression.Not(null, preamble.filter),
429	request.filter
430	]), request.schema);
431	} else if (preamble !== null) {	43,934✔
432	// convert the preamble into a request by negating it
433	// shallow clone
434	assert(preamble instanceof Ast.Table.Filter);	50✔
435	request = new Ast.Table.Filter(null, preamble.table, preamble.filter, preamble.schema);	50✔
436	request.filter = new Ast.BooleanExpression.Not(null, request.filter);	50✔
437	}
438	assert(request !== null);	43,971✔
439
440	const idType = request.schema.getArgType('id');	43,971✔
441
442	if (!idType \|\| !idType.equals(proposalType))	43,971✔
443	return null;	32,127✔
444
445	return request;	11,844✔
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 / 1073

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