1626

pending completion

Build # 1626

Build Type

Pull #454

travis-ci-com

Committed by

web-flow

Commit Message

Merge b58f78b8b into d418bae62

Pull Request Pull Request #454: describe: avoid deprecated API

Run Details

10749 of 23184 branches covered (46.36%)

Branch coverage included in aggregate %.

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

17 existing lines in 6 files now uncovered.

25221 of 43762 relevant lines covered (57.63%)

535926.04 hits per line

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

88.24

/languages/thingtalk/dialogue_acts/results.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, Type } from 'thingtalk';

import * as C from '../ast_manip';
import {
    ContextInfo
} from '../state_manip';
import { SlotBag } from '../slot_bag';

import {
    isInfoPhraseCompatibleWithResult,
    isSlotCompatibleWithResult,
} from './common';

const MAX_RESULTS = 3;

// a phrase that describes one or more results using slots
export interface ResultPhrase {
    ctx : ContextInfo;
    info : SlotBag;
    compatible : number[];
}

export function resultPhraseKeyFn(phrase : ResultPhrase) {
    return {
        functionName: phrase.ctx.currentFunction!.qualifiedName
    };
}

export function mergeResultPhrase(p1 : ResultPhrase, p2 : ResultPhrase) : ResultPhrase|null {
    assert(p1.ctx === p2.ctx);

    // check that both are compatible with some result, by intersecting
    // the compatible arrays
    const compatible : number[] = [];
    for (const resultIdx of p1.compatible) {
        if (p2.compatible.includes(resultIdx))
            compatible.push(resultIdx);
    }
    if (compatible.length === 0)
        return null;

    // this will also check that they don't both say the same thing
    const merged = SlotBag.merge(p1.info, p2.info);
    if (!merged)
        return null;

    return { ctx: p1.ctx, info: merged, compatible };
}

export function makeResultPhrase(ctx : ContextInfo, info : SlotBag) : ResultPhrase|null {
    if (info.schema !== null) {
        if (!C.isSameFunction(ctx.currentFunction!, info.schema))
            return null;
    }

    // check that the filter is compatible with at least one of the top 3 results
    const results = ctx.results!;
    const compatible : number[] = [];
    for (let i = 0; i < Math.min(MAX_RESULTS, results.length); i++) {
        if (isInfoPhraseCompatibleWithResult(results[i], info)) {
            compatible.push(i);
            break;
        }
    }
    if (compatible.length === 0)
        return null;

    if (info.schema !== null)
        return { ctx, info, compatible };

    const clone = info.clone();
    clone.schema = ctx.currentFunction;
    return { ctx, info: clone, compatible };
}

function addSlotToBagCloned(bag : SlotBag, filter : Ast.BooleanExpression) : [SlotBag, string[]]|null {
    if (filter instanceof Ast.AndBooleanExpression) {
        // we treat "serves Italian and Chinese" the same as "serves Italian or Chinese"

        let newBag : SlotBag|null = bag;
        const newSlots : string[] = [];
        for (const operand of filter.operands) {
            const added = addSlotToBagCloned(newBag, operand);
            if (!added)
                return null;
            newBag = added[0];
            newSlots.push(...added[1]);
        }
        return [newBag, newSlots];
    }
    if (!(filter instanceof Ast.AtomBooleanExpression))
        return null;

    const arg = bag.schema!.getArgument(filter.name);
    if (!arg || arg.is_input)
        return null;
    const ptype = arg.type;
    const vtype = filter.value.getType();
    if (filter.operator === 'contains' || filter.operator === 'contains~') {
        if (!ptype.equals(new Type.Array(vtype)))
            return null;
        const existing = bag.get(filter.name);
        if (existing) {
            assert(existing instanceof Ast.ArrayValue);
            if (existing.value.some((v) => v.equals(filter.value)))
                return null;
            existing.value.push(filter.value);
        } else {
            bag.set(filter.name, new Ast.Value.Array([filter.value]));
        }
        return [bag, [filter.name]];
    } else {
        if (filter.operator !== '==' && filter.operator !== '=~')
            return null;
        if (!ptype.equals(vtype))
            return null;
        if (bag.has(filter.name))
            return null;
        bag.set(filter.name, filter.value);
        return [bag, [filter.name]];
    }

}

export function addSlotToBag(bag : SlotBag, filter : C.FilterSlot) : [SlotBag, string[]]|null {
    const schema = bag.schema!;
    if (!C.isSameFunction(schema, filter.schema))
        return null;

    let name;
    if (filter.ast instanceof Ast.AndBooleanExpression) {
        const atom = filter.ast.operands[0];
        if (!(atom instanceof Ast.AtomBooleanExpression))
            return null;
        name = atom.name;
    } else {
        if (!(filter.ast instanceof Ast.AtomBooleanExpression))
            return null;
        name = filter.ast.name;
    }
    if (bag.has(name))
        return null;

    const clone = bag.clone();
    return addSlotToBagCloned(clone, filter.ast);
}

export function addSlotToResultPhrase(phrase : ResultPhrase, filter : C.FilterSlot) : ResultPhrase|null {
    const added = addSlotToBag(phrase.info, filter);
    if (!added)
        return null;
    const [newBag, newSlots] = added;

    const compatible : number[] = [];
    const results = phrase.ctx.results!;
    for (const resultIdx of phrase.compatible) {
        const result = results[resultIdx];
        let good = true;
        for (const newSlot of newSlots) {
            if (!isSlotCompatibleWithResult(result, newSlot, newBag.get(newSlot)!)) {
                good = false;
                break;
            }
        }
        if (good)
            compatible.push(resultIdx);
    }
    if (compatible.length === 0)
        return null;
    return { ctx: phrase.ctx, info: newBag, compatible };
}

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';	2✔
23	import { Ast, Type } from 'thingtalk';	2✔
24
25	import * as C from '../ast_manip';	2✔
26	import {
27	ContextInfo
28	} from '../state_manip';
29	import { SlotBag } from '../slot_bag';	2✔
30
31	import {	2✔
32	isInfoPhraseCompatibleWithResult,
33	isSlotCompatibleWithResult,
34	} from './common';
35
36	const MAX_RESULTS = 3;	2✔
37
38	// a phrase that describes one or more results using slots
39	export interface ResultPhrase {
40	ctx : ContextInfo;
41	info : SlotBag;
42	compatible : number[];
43	}
44
45	export function resultPhraseKeyFn(phrase : ResultPhrase) {	2✔
46	return {	12,102✔
47	functionName: phrase.ctx.currentFunction!.qualifiedName
48	};
49	}
50
51	export function mergeResultPhrase(p1 : ResultPhrase, p2 : ResultPhrase) : ResultPhrase\|null {	2✔
52	assert(p1.ctx === p2.ctx);	2,081✔
53
54	// check that both are compatible with some result, by intersecting
55	// the compatible arrays
56	const compatible : number[] = [];	2,081✔
57	for (const resultIdx of p1.compatible) {	2,081✔
58	if (p2.compatible.includes(resultIdx))	2,081✔
59	compatible.push(resultIdx);	1,940✔
60	}
61	if (compatible.length === 0)	2,081✔
62	return null;	141✔
63
64	// this will also check that they don't both say the same thing
65	const merged = SlotBag.merge(p1.info, p2.info);	1,940✔
66	if (!merged)	1,940✔
67	return null;	1,863✔
68
69	return { ctx: p1.ctx, info: merged, compatible };	77✔
70	}
71
72	export function makeResultPhrase(ctx : ContextInfo, info : SlotBag) : ResultPhrase\|null {	2✔
73	if (info.schema !== null) {	841,166✔
74	if (!C.isSameFunction(ctx.currentFunction!, info.schema))	766,376!
75	return null;	×
76	}
77
78	// check that the filter is compatible with at least one of the top 3 results
79	const results = ctx.results!;	841,166✔
80	const compatible : number[] = [];	841,166✔
81	for (let i = 0; i < Math.min(MAX_RESULTS, results.length); i++) {	841,166✔
82	if (isInfoPhraseCompatibleWithResult(results[i], info)) {	2,411,816✔
83	compatible.push(i);	748✔
84	break;	748✔
85	}
86	}
87	if (compatible.length === 0)	841,166✔
88	return null;	840,418✔
89
90	if (info.schema !== null)	748!
91	return { ctx, info, compatible };	748✔
92
UNCOV 93	const clone = info.clone();	×
UNCOV 94	clone.schema = ctx.currentFunction;	×
UNCOV 95	return { ctx, info: clone, compatible };	×
96	}
97
98	function addSlotToBagCloned(bag : SlotBag, filter : Ast.BooleanExpression) : [SlotBag, string[]]\|null {
99	if (filter instanceof Ast.AndBooleanExpression) {	1,946,294✔
100	// we treat "serves Italian and Chinese" the same as "serves Italian or Chinese"
101
102	let newBag : SlotBag\|null = bag;	558,802✔
103	const newSlots : string[] = [];	558,802✔
104	for (const operand of filter.operands) {	558,802✔
105	const added = addSlotToBagCloned(newBag, operand);	784,314✔
106	if (!added)	784,314✔
107	return null;	333,290✔
108	newBag = added[0];	451,024✔
109	newSlots.push(...added[1]);	451,024✔
110	}
111	return [newBag, newSlots];	225,512✔
112	}
113	if (!(filter instanceof Ast.AtomBooleanExpression))	1,387,492!
114	return null;	×
115
116	const arg = bag.schema!.getArgument(filter.name);	1,387,492✔
117	if (!arg \|\| arg.is_input)	1,387,492!
118	return null;	×
119	const ptype = arg.type;	1,387,492✔
120	const vtype = filter.value.getType();	1,387,492✔
121	if (filter.operator === 'contains' \|\| filter.operator === 'contains~') {	1,387,492✔
122	if (!ptype.equals(new Type.Array(vtype)))	617,733✔
123	return null;	137,543✔
124	const existing = bag.get(filter.name);	480,190✔
125	if (existing) {	480,190✔
126	assert(existing instanceof Ast.ArrayValue);	225,512✔
127	if (existing.value.some((v) => v.equals(filter.value)))	225,512!
128	return null;	×
129	existing.value.push(filter.value);	225,512✔
130	} else {
131	bag.set(filter.name, new Ast.Value.Array([filter.value]));	254,678✔
132	}
133	return [bag, [filter.name]];	480,190✔
134	} else {
135	if (filter.operator !== '==' && filter.operator !== '=~')	769,759✔
136	return null;	200,555✔
137	if (!ptype.equals(vtype))	569,204✔
138	return null;	9,082✔
139	if (bag.has(filter.name))	560,122!
140	return null;	×
141	bag.set(filter.name, filter.value);	560,122✔
142	return [bag, [filter.name]];	560,122✔
143	}
144
145	}
146
147	export function addSlotToBag(bag : SlotBag, filter : C.FilterSlot) : [SlotBag, string[]]\|null {	2✔
148	const schema = bag.schema!;	1,950,927✔
149	if (!C.isSameFunction(schema, filter.schema))	1,950,927!
150	return null;	×
151
152	let name;
153	if (filter.ast instanceof Ast.AndBooleanExpression) {	1,950,927✔
154	const atom = filter.ast.operands[0];	1,183,481✔
155	if (!(atom instanceof Ast.AtomBooleanExpression))	1,183,481!
156	return null;	×
157	name = atom.name;	1,183,481✔
158	} else {
159	if (!(filter.ast instanceof Ast.AtomBooleanExpression))	767,446!
160	return null;	×
161	name = filter.ast.name;	767,446✔
162	}
163	if (bag.has(name))	1,950,927✔
164	return null;	788,947✔
165
166	const clone = bag.clone();	1,161,980✔
167	return addSlotToBagCloned(clone, filter.ast);	1,161,980✔
168	}
169
170	export function addSlotToResultPhrase(phrase : ResultPhrase, filter : C.FilterSlot) : ResultPhrase\|null {	2✔
171	const added = addSlotToBag(phrase.info, filter);	1,769,563✔
172	if (!added)	1,769,563✔
173	return null;	1,053,784✔
174	const [newBag, newSlots] = added;	715,779✔
175
176	const compatible : number[] = [];	715,779✔
177	const results = phrase.ctx.results!;	715,779✔
178	for (const resultIdx of phrase.compatible) {	715,779✔
179	const result = results[resultIdx];	715,779✔
180	let good = true;	715,779✔
181	for (const newSlot of newSlots) {	715,779✔
182	if (!isSlotCompatibleWithResult(result, newSlot, newBag.get(newSlot)!)) {	715,779✔
183	good = false;	707,998✔
184	break;	707,998✔
185	}
186	}
187	if (good)	715,779✔
188	compatible.push(resultIdx);	7,781✔
189	}
190	if (compatible.length === 0)	715,779✔
191	return null;	707,998✔
192	return { ctx: phrase.ctx, info: newBag, compatible };	7,781✔
193	}

stanford-oval / genie-toolkit / 1626

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