1177

pending completion

Build # 1177

Build Type

Pull #276

travis-ci-com

Committed by

web-flow

Commit Message

Merge c14a0d5cc into fcdfbc6a0

Pull Request Pull Request #276: bug fix in entity matching

Run Details

6681 of 12543 branches covered (53.26%)

Branch coverage included in aggregate %.

5 of 5 new or added lines in 1 file covered. (100.0%)

142 existing lines in 5 files now uncovered.

15306 of 24193 relevant lines covered (63.27%)

1227086.27 hits per line

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

23.63

/languages/thingtalk/dialogue_acts/common.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 { arraySubset } = require('../array_utils');
const {
    setOrAddInvocationParam,
} = require('../state_manip');


function isFilterCompatibleWithInfo(info, filter) {
    assert(filter instanceof Ast.BooleanExpression);
    if (filter.isTrue || filter.isDontCare)
        return true;
    if (filter.isFalse)
        return false;
    if (filter.isOr)
        return filter.operands.some((op) => isFilterCompatibleWithInfo(info, op));
    if (filter.isAnd)
        return filter.operands.every((op) => isFilterCompatibleWithInfo(info, op));
    if (filter.isNot)
        return !isFilterCompatibleWithInfo(info, filter.expr);

    // approximate
    if (filter.isExternal || filter.isCompute)
        return true;

    assert(filter.isAtom);
    const pname = filter.name;
    if (!info.has(pname))
        return false;

    if (!filter.value.isConstant())
        return true;

    switch (filter.operator) {
    case '==':
    case '=~':
        return filter.value.equals(info.get(pname));

    case 'contains':
    case 'contains~':
        return info.get(pname).value.some((v) => v.equals(filter.value));

    case 'in_array':
    case 'in_array~':
        return filter.value.value.some((v) => v.equals(info.get(pname)));

    case '>=':
        return info.get(pname).toJS() >= filter.value.toJS();
    case '<=':
        return info.get(pname).toJS() <= filter.value.toJS();

    default:
        // approximate
        return true;
    }
}

function isFilterCompatibleWithResult(topResult, filter) {
    if (filter.isTrue || filter.isDontCare)
        return true;
    if (filter.isFalse)
        return false;
    if (filter.isAnd)
        return filter.operands.every((op) => isFilterCompatibleWithResult(topResult, op));
    if (filter.isOr)
        return filter.operands.some((op) => isFilterCompatibleWithResult(topResult, op));
    if (filter.isNot)
        return !isFilterCompatibleWithResult(topResult, filter.expr);

    if (filter.isExternal) // approximate
        return true;

    if (filter.isCompute) // approximate
        return true;

    const values = topResult.value;

    // if the value was not returned, don't verbalize it
    if (!values[filter.name])
        return false;

    const resultValue = topResult.value[filter.name];

    if (resultValue.isEntity) {
        // approximate: all strings are made up so we don't need a true likeTest here
        if (filter.operator === '=~')
            return resultValue.display === filter.value.toJS();
        else
            return String(resultValue.toJS()) === String(filter.value.toJS());
    }

    switch (filter.operator) {
    case '==':
    case '=~':
        // approximate: all strings are made up so we don't need a true likeTest here
        return String(resultValue.toJS()) === String(filter.value.toJS());

    default:
        // approximate
        return true;
    }
}

function isInfoPhraseCompatibleWithResult(topResult, info) {
    for (let [pname, infoValue] of info) {
        const resultValue = topResult.value[pname];
        if (!resultValue)
            return false;

        if (resultValue.isArray && infoValue.isArray) {
            if (!arraySubset(infoValue.value, resultValue.value))
                return false;
        } else {
            if (!resultValue.equals(infoValue))
                return false;
        }
    }
    return true;
}

/**
 * Check if asking a question on the parameters "questions" is allowed.
 *
 * This checks two things: that all parameters are valid output parameters of the table,
 * and all parameters are filterable.
 */
function isValidSearchQuestion(table, questions) {
    for (let q of questions) {
        const arg = table.schema.getArgument(q);
        if (!arg || arg.is_input)
            return false;
        if (arg.getAnnotation('filterable') === false)
            return false;
    }
    return true;
}


function addParametersFromContext(toInvocation, fromInvocation) {
    let newParams = new Set;
    for (let in_param of toInvocation.in_params) {
        if (in_param.value.isUndefined)
            continue;
        newParams.add(in_param.name);
    }

    let cloned = false;

    for (let in_param of fromInvocation.in_params) {
        if (in_param.value.isUndefined)
            continue;
        if (newParams.has(in_param.name))
            continue;

        if (!cloned) {
            toInvocation = toInvocation.clone();
            cloned = true;
        }

        setOrAddInvocationParam(toInvocation, in_param.name, in_param.value);
    }

    return toInvocation;
}

function findChainParam(topResult, action) {
    const resultType = topResult.value.id.getType();

    let chainParam = undefined;
    for (let arg of action.schema.iterateArguments()) {
        if (arg.type.equals(resultType)) {
            chainParam = arg.name;
            break;
        }
    }
    return chainParam;
}

function isSimpleFilterTable(table) {
    return table.isFilter && ((table.table.isCompute && table.table.table.isInvocation) || table.table.isInvocation);
}

module.exports = {
    isFilterCompatibleWithInfo,
    isFilterCompatibleWithResult,
    isInfoPhraseCompatibleWithResult,
    isValidSearchQuestion,
    isSimpleFilterTable,
    findChainParam,
    addParametersFromContext,
};

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 { arraySubset } = require('../array_utils');	3✔
28	const {
29	setOrAddInvocationParam,
30	} = require('../state_manip');	3✔
31
32
33	function isFilterCompatibleWithInfo(info, filter) {
UNCOV 34	assert(filter instanceof Ast.BooleanExpression);	×
UNCOV 35	if (filter.isTrue \|\| filter.isDontCare)	×
36	return true;	×
UNCOV 37	if (filter.isFalse)	×
38	return false;	×
UNCOV 39	if (filter.isOr)	×
40	return filter.operands.some((op) => isFilterCompatibleWithInfo(info, op));	×
UNCOV 41	if (filter.isAnd)	×
UNCOV 42	return filter.operands.every((op) => isFilterCompatibleWithInfo(info, op));	×
UNCOV 43	if (filter.isNot)	×
44	return !isFilterCompatibleWithInfo(info, filter.expr);	×
45
46	// approximate
UNCOV 47	if (filter.isExternal \|\| filter.isCompute)	×
48	return true;	×
49
UNCOV 50	assert(filter.isAtom);	×
UNCOV 51	const pname = filter.name;	×
UNCOV 52	if (!info.has(pname))	×
UNCOV 53	return false;	×
54
UNCOV 55	if (!filter.value.isConstant())	×
56	return true;	×
57
UNCOV 58	switch (filter.operator) {	×
59	case '==':
60	case '=~':
UNCOV 61	return filter.value.equals(info.get(pname));	×
62
63	case 'contains':
64	case 'contains~':
65	return info.get(pname).value.some((v) => v.equals(filter.value));	×
66
67	case 'in_array':
68	case 'in_array~':
69	return filter.value.value.some((v) => v.equals(info.get(pname)));	×
70
71	case '>=':
72	return info.get(pname).toJS() >= filter.value.toJS();	×
73	case '<=':
74	return info.get(pname).toJS() <= filter.value.toJS();	×
75
76	default:
77	// approximate
78	return true;	×
79	}
80	}
81
82	function isFilterCompatibleWithResult(topResult, filter) {
83	if (filter.isTrue \|\| filter.isDontCare)	×
84	return true;	×
85	if (filter.isFalse)	×
86	return false;	×
87	if (filter.isAnd)	×
88	return filter.operands.every((op) => isFilterCompatibleWithResult(topResult, op));	×
89	if (filter.isOr)	×
90	return filter.operands.some((op) => isFilterCompatibleWithResult(topResult, op));	×
91	if (filter.isNot)	×
92	return !isFilterCompatibleWithResult(topResult, filter.expr);	×
93
94	if (filter.isExternal) // approximate	×
95	return true;	×
96
97	if (filter.isCompute) // approximate	×
98	return true;	×
99
100	const values = topResult.value;	×
101
102	// if the value was not returned, don't verbalize it
103	if (!values[filter.name])	×
104	return false;	×
105
106	const resultValue = topResult.value[filter.name];	×
107
108	if (resultValue.isEntity) {	×
109	// approximate: all strings are made up so we don't need a true likeTest here
110	if (filter.operator === '=~')	×
111	return resultValue.display === filter.value.toJS();	×
112	else
113	return String(resultValue.toJS()) === String(filter.value.toJS());	×
114	}
115
116	switch (filter.operator) {	×
117	case '==':
118	case '=~':
119	// approximate: all strings are made up so we don't need a true likeTest here
120	return String(resultValue.toJS()) === String(filter.value.toJS());	×
121
122	default:
123	// approximate
124	return true;	×
125	}
126	}
127
128	function isInfoPhraseCompatibleWithResult(topResult, info) {
129	for (let [pname, infoValue] of info) {	387,838✔
130	const resultValue = topResult.value[pname];	409,167✔
131	if (!resultValue)	409,167✔
132	return false;	25,891✔
133
134	if (resultValue.isArray && infoValue.isArray) {	383,276✔
135	if (!arraySubset(infoValue.value, resultValue.value))	18,005✔
136	return false;	11,811✔
137	} else {
138	if (!resultValue.equals(infoValue))	365,271✔
139	return false;	337,656✔
140	}
141	}
142	return true;	12,480✔
143	}
144
145	/**
146	* Check if asking a question on the parameters "questions" is allowed.
147	*
148	* This checks two things: that all parameters are valid output parameters of the table,
149	* and all parameters are filterable.
150	*/
151	function isValidSearchQuestion(table, questions) {
152	for (let q of questions) {	26,463✔
153	const arg = table.schema.getArgument(q);	30,110✔
154	if (!arg \|\| arg.is_input)	30,110✔
155	return false;	12,306✔
156	if (arg.getAnnotation('filterable') === false)	17,804✔
157	return false;	3,489✔
158	}
159	return true;	10,668✔
160	}
161
162
163	function addParametersFromContext(toInvocation, fromInvocation) {
164	let newParams = new Set;	×
165	for (let in_param of toInvocation.in_params) {	×
166	if (in_param.value.isUndefined)	×
167	continue;	×
168	newParams.add(in_param.name);	×
169	}
170
171	let cloned = false;	×
172
173	for (let in_param of fromInvocation.in_params) {	×
174	if (in_param.value.isUndefined)	×
175	continue;	×
176	if (newParams.has(in_param.name))	×
177	continue;	×
178
179	if (!cloned) {	×
180	toInvocation = toInvocation.clone();	×
181	cloned = true;	×
182	}
183
184	setOrAddInvocationParam(toInvocation, in_param.name, in_param.value);	×
185	}
186
187	return toInvocation;	×
188	}
189
190	function findChainParam(topResult, action) {
UNCOV 191	const resultType = topResult.value.id.getType();	×
192
UNCOV 193	let chainParam = undefined;	×
UNCOV 194	for (let arg of action.schema.iterateArguments()) {	×
UNCOV 195	if (arg.type.equals(resultType)) {	×
UNCOV 196	chainParam = arg.name;	×
UNCOV 197	break;	×
198	}
199	}
UNCOV 200	return chainParam;	×
201	}
202
203	function isSimpleFilterTable(table) {
204	return table.isFilter && ((table.table.isCompute && table.table.table.isInvocation) \|\| table.table.isInvocation);	104,171!
205	}
206
207	module.exports = {	3✔
208	isFilterCompatibleWithInfo,
209	isFilterCompatibleWithResult,
210	isInfoPhraseCompatibleWithResult,
211	isValidSearchQuestion,
212	isSimpleFilterTable,
213	findChainParam,
214	addParametersFromContext,
215	};

stanford-oval / genie-toolkit / 1177

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