1074

pending completion

Build # 1074

Build Type

Pull #246

travis-ci-com

Committed by

web-flow

Commit Message

Merge c38d5a6ed into f1ddda6ad

Pull Request Pull Request #246: Two small bug fixes

Run Details

6743 of 12270 branches covered (54.96%)

Branch coverage included in aggregate %.

4 of 6 new or added lines in 3 files covered. (66.67%)

6 existing lines in 3 files now uncovered.

15393 of 23817 relevant lines covered (64.63%)

2863046.52 hits per line

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

45.6

/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) {
34	assert(filter instanceof Ast.BooleanExpression);	206,554✔
35	if (filter.isTrue \|\| filter.isDontCare)	206,554!
36	return true;	×
37	if (filter.isFalse)	206,554!
38	return false;	×
39	if (filter.isOr)	206,554!
40	return filter.operands.some((op) => isFilterCompatibleWithInfo(info, op));	×
41	if (filter.isAnd)	206,554✔
42	return filter.operands.every((op) => isFilterCompatibleWithInfo(info, op));	62,132✔
43	if (filter.isNot)	144,655!
44	return !isFilterCompatibleWithInfo(info, filter.expr);	×
45
46	// approximate
47	if (filter.isExternal \|\| filter.isCompute)	144,655!
48	return true;	×
49
50	assert(filter.isAtom);	144,655✔
51	const pname = filter.name;	144,655✔
52	if (!info.has(pname))	144,655✔
53	return false;	135,485✔
54
55	if (!filter.value.isConstant())	9,170!
56	return true;	×
57
58	switch (filter.operator) {	9,170!
59	case '==':
60	case '=~':
61	return filter.value.equals(info.get(pname));	9,170✔
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 '>=':
UNCOV 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) {	420,541✔
130	const resultValue = topResult.value[pname];	450,115✔
131	if (!resultValue)	450,115✔
132	return false;	27,210✔
133
134	if (resultValue.isArray && infoValue.isArray) {	422,905✔
135	if (!arraySubset(infoValue.value, resultValue.value))	18,005✔
136	return false;	11,811✔
137	} else {
138	if (!resultValue.equals(infoValue))	404,900✔
139	return false;	367,600✔
140	}
141	}
142	return true;	13,920✔
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) {	61,345✔
153	const arg = table.schema.getArgument(q);	63,190✔
154	if (!arg \|\| arg.is_input)	63,190✔
155	return false;	11,814✔
156	if (arg.getAnnotation('filterable') === false)	51,376✔
157	return false;	1,021✔
158	}
159	return true;	48,510✔
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) {
191	const resultType = topResult.value.id.getType();	421✔
192
193	let chainParam = undefined;	421✔
194	for (let arg of action.schema.iterateArguments()) {	421✔
195	if (arg.type.equals(resultType)) {	617✔
196	chainParam = arg.name;	372✔
197	break;	372✔
198	}
199	}
200	return chainParam;	421✔
201	}
202
203	function isSimpleFilterTable(table) {
204	return table.isFilter && ((table.table.isCompute && table.table.table.isInvocation) \|\| table.table.isInvocation);	220,574!
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 / 1074

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