2070

pending completion

Build # 2070

Build Type

Pull #647

travis-ci-com

Committed by

web-flow

Commit Message

Merge eb7e55174 into f5384605a

Pull Request Pull Request #647: Fix ts-node not finding .d.ts files

Run Details

9900 of 19994 branches covered (49.51%)

Branch coverage included in aggregate %.

32 of 33 new or added lines in 5 files covered. (96.97%)

10 existing lines in 8 files now uncovered.

23423 of 39441 relevant lines covered (59.39%)

468774.77 hits per line

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

61.42

/lib/dialogue-agent/simulator/statement_simulator.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,
    Compiler,
    SchemaRetriever,
    Runtime,
    Builtin
} from 'thingtalk';

import {
    ResultGenerator,
    SimulationExecEnvironment,
    SimulatedError
} from './simulation_exec_environment';
import { SimulationDatabase } from './types';

// above MORE_SIZE, we set the "more" bit
const MORE_SIZE = 50;
// above PAGE_SIZE, we set the count but don't actually show the full list of results
const PAGE_SIZE = 10;

interface SimulatorOptions {
    locale : string;
    timezone : string|undefined;
    schemaRetriever : SchemaRetriever;
    rng : () => number;
    database ?: SimulationDatabase;
    overrides ?: Map<string, string>;
}

type RawExecutionResult = Array<[string, Record<string, unknown>]>;
type ExecutionResult = [Ast.DialogueHistoryResultList, RawExecutionResult];

export class ThingTalkSimulatorState {
    private _locale : string;
    private _schemas : SchemaRetriever;
    private _rng : () => number;
    private _database : SimulationDatabase|undefined;
    private _overrides : Map<string, string>;
    private _execEnv : SimulationExecEnvironment;

    constructor(options : SimulatorOptions) {
        this._locale = options.locale;
        this._schemas = options.schemaRetriever;
        this._rng = options.rng;
        this._database = options.database;
        this._overrides = options.overrides || new Map;

        this._execEnv = new SimulationExecEnvironment(this._locale, options.timezone, this._schemas, this._database, {
            rng: this._rng
        });
    }

    async compile(stmt : Ast.ExpressionStatement, cache : Map<string, Runtime.CompiledProgram>) : Promise<Runtime.CompiledProgram> {
        const clone = stmt.clone();

        const program = new Ast.Program(null, [], [], [clone]);
        const cacheKey = program.prettyprint();
        //console.error(cacheKey);

        let compiled = cache.get(cacheKey);
        if (compiled)
            return compiled;

        try {
            const compiler = new Compiler(this._schemas);

            compiled = await compiler.compileProgram(program);
            assert(compiled.rules.length === 0);
            cache.set(cacheKey, compiled);
        } catch(e) {
            console.error(`Failed to compile program: ` + e.message);
            console.error(program.prettyprint());
            throw e;
        }
        return compiled;
    }

    async simulate(stmt : Ast.ExpressionStatement, compiled : Runtime.CompiledProgram) : Promise<ExecutionResult> {
        const results : Ast.DialogueHistoryResultItem[] = [];
        const rawResults : RawExecutionResult = [];
        let error : Ast.Value|null = null;
        const generator = new ResultGenerator(this._rng, this._overrides);
        for (const slot of stmt.iterateSlots2()) {
            if (slot instanceof Ast.DeviceSelector)
                continue;
            generator.addCandidate(slot.get());
        }
        this._execEnv.generator = generator;

        this._execEnv.setOutputDelegate({
            output: async (outputType : string, outputValue : { [key : string] : unknown }) => {
                const mapped = new Ast.DialogueHistoryResultItem(null, await this._mapResult(outputType, outputValue));
                results.push(mapped);
                rawResults.push([outputType, outputValue]);
            },
            error: (err) => {
                if (!(err instanceof SimulatedError)) {
                    console.error(`Failed to execute program`);
                    console.error(err);
                    console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());
                    process.exit(1);
                    return;
                }
                if (err.code)
                    error = new Ast.Value.Enum(err.code);
                else
                    error = new Ast.Value.String(err.message);
            }
        });

        try {
            assert(typeof compiled.command === 'function');
            await compiled.command(this._execEnv);
        } catch(e) {
            console.error(`Failed to execute program: ` + e.message);
            console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());
            throw e;
        }

        const numResults = results.length;
        return [new Ast.DialogueHistoryResultList(null, results.slice(0, PAGE_SIZE),
            new Ast.Value.Number(Math.min(MORE_SIZE, numResults)), numResults > MORE_SIZE, error), rawResults];
    }

    private _inferType(key : string, jsValue : unknown) : Type {
        if (key === 'distance') // HACK
            return new Type.Measure('m');
        if (key === '__device')
            return new Type.Entity('tt:device_id');
        if (typeof jsValue === 'boolean')
            return Type.Boolean;
        if (typeof jsValue === 'string')
            return Type.String;
        if (typeof jsValue === 'number')
            return Type.Number;
        if (jsValue instanceof Builtin.Currency)
            return Type.Currency;
        if (jsValue instanceof Builtin.Entity)
            return new Type.Entity('');
        if (jsValue instanceof Builtin.Time)
            return Type.Time;
        if (jsValue instanceof Date)
            return Type.Date;
        if (Array.isArray(jsValue) && jsValue.length > 0)
            return new Type.Array(this._inferType(key, jsValue[0]));
        if (Array.isArray(jsValue))
            return new Type.Array(Type.Any);

        return Type.Any;
    }

    private _outputTypeToSchema(outputType : string) : Promise<Ast.FunctionDef> {
        const [kind, fname] = outputType.split(':');
        let ftype : 'query'|'action' = 'query';

        let fname_ = fname;
        if (fname_.startsWith('action/')) {
            ftype = 'action';
            fname_ = fname_.substring('action/'.length);
        }
        return this._schemas.getSchemaAndNames(kind, ftype, fname_);
    }

    private async _mapResult(outputType : string|null, outputValue : { [key : string] : unknown }) : Promise<{ [key : string] : Ast.Value }> {
        const mappedResult : { [key : string] : Ast.Value } = {};
        if (outputType === null) {
            // fallback
            for (const key in outputValue) {
                const jsValue = outputValue[key];
                mappedResult[key] = Ast.Value.fromJS(this._inferType(key, jsValue), jsValue);
            }
            return mappedResult;
        }

        if (outputType.indexOf('+') >= 0) {
            const types = outputType.split('+');
            outputType = types[types.length-1];
        }

        const aggregation = /^([a-zA-Z]+)\(([^)]+)\)$/.exec(outputType);
        if (aggregation !== null) {
            let operator;
            [, operator, outputType] = aggregation;

            const field = Object.keys(outputValue)[0];
            const value = outputValue[field];
            if (operator === 'count') {
                mappedResult[field] = Ast.Value.fromJS(Type.Number, outputValue[field]);
                return mappedResult;
            }

            const schema = await this._outputTypeToSchema(outputType);
            const type = schema.getArgType(field) || this._inferType(field, value);
            mappedResult[field] = Ast.Value.fromJS(type, value);
        } else {
            const schema = await this._outputTypeToSchema(outputType);

            for (const key in outputValue) {
                const value = outputValue[key];
                if (value === null || value === undefined)
                    continue;
                const type = schema.getArgType(key) || this._inferType(key, value);
                if (type instanceof Type.Compound)
                    mappedResult[key] = this._mapCompound(key + '.', schema, value as { [key : string] : unknown });
                else
                    mappedResult[key] = Ast.Value.fromJS(type, value);
            }
        }
        return mappedResult;
    }

    private _mapCompound(prefix : string, schema : Ast.FunctionDef, object : { [key : string] : unknown }) : Ast.Value {
        const result : { [key : string] : Ast.Value } = {};
        for (const key in object) {
            const value = object[key];
            const type = schema.getArgType(prefix + key) || this._inferType(key, value);
            if (type instanceof Type.Compound)
                result[key] = this._mapCompound(prefix + key + '.', schema, object as { [key : string] : unknown });
            else
                result[key] = Ast.Value.fromJS(type, value);
        }
        return new Ast.Value.Object(result);
    }
}

/**
 * Simulate the execution of ThingTalk code.
 */
export default class ThingTalkStatementSimulator {
    private _options : SimulatorOptions;
    private cache : Map<string, Runtime.CompiledProgram>;

    constructor(options : SimulatorOptions) {
        this._options = options;
        this.cache = new Map;
    }

    async executeStatement(stmt : Ast.ExpressionStatement,
                           execState : ThingTalkSimulatorState) : Promise<[Ast.DialogueHistoryResultList, RawExecutionResult, undefined, ThingTalkSimulatorState]> {
        if (stmt.stream) {
            // nothing to do, this always returns nothing
            return [new Ast.DialogueHistoryResultList(null, [],
                new Ast.Value.Number(0), false, null), [], undefined, execState];
        }

        if (execState === undefined)
            execState = new ThingTalkSimulatorState(this._options);

        // there is no way around this, we need to compile and run the program!
        const compiled = await execState.compile(stmt, this.cache);
        const [resultList, rawResults] = await execState.simulate(stmt, compiled);
        // ignore the new program record, it doesn't matter at simulation time
        return [resultList, rawResults, undefined, execState];
    }
}

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';	111✔
23
24	import {	111✔
25	Ast,
26	Type,
27	Compiler,
28	SchemaRetriever,
29	Runtime,
30	Builtin
31	} from 'thingtalk';
32
33	import {	111✔
34	ResultGenerator,
35	SimulationExecEnvironment,
36	SimulatedError
37	} from './simulation_exec_environment';
38	import { SimulationDatabase } from './types';
39
40	// above MORE_SIZE, we set the "more" bit
41	const MORE_SIZE = 50;	111✔
42	// above PAGE_SIZE, we set the count but don't actually show the full list of results
43	const PAGE_SIZE = 10;	111✔
44
45	interface SimulatorOptions {
46	locale : string;
47	timezone : string\|undefined;
48	schemaRetriever : SchemaRetriever;
49	rng : () => number;
50	database ?: SimulationDatabase;
51	overrides ?: Map<string, string>;
52	}
53
54	type RawExecutionResult = Array<[string, Record<string, unknown>]>;
55	type ExecutionResult = [Ast.DialogueHistoryResultList, RawExecutionResult];
56
57	export class ThingTalkSimulatorState {	111✔
58	private _locale : string;
59	private _schemas : SchemaRetriever;
60	private _rng : () => number;
61	private _database : SimulationDatabase\|undefined;
62	private _overrides : Map<string, string>;
63	private _execEnv : SimulationExecEnvironment;
64
65	constructor(options : SimulatorOptions) {
66	this._locale = options.locale;	3,872✔
67	this._schemas = options.schemaRetriever;	3,872✔
68	this._rng = options.rng;	3,872✔
69	this._database = options.database;	3,872✔
70	this._overrides = options.overrides \|\| new Map;	3,872✔
71
72	this._execEnv = new SimulationExecEnvironment(this._locale, options.timezone, this._schemas, this._database, {	3,872✔
73	rng: this._rng
74	});
75	}
76
77	async compile(stmt : Ast.ExpressionStatement, cache : Map<string, Runtime.CompiledProgram>) : Promise<Runtime.CompiledProgram> {
78	const clone = stmt.clone();	8,581✔
79
80	const program = new Ast.Program(null, [], [], [clone]);	8,581✔
81	const cacheKey = program.prettyprint();	8,581✔
82	//console.error(cacheKey);
83
84	let compiled = cache.get(cacheKey);	8,581✔
85	if (compiled)	8,581✔
86	return compiled;	5,575✔
87
88	try {	3,006✔
89	const compiler = new Compiler(this._schemas);	3,006✔
90
91	compiled = await compiler.compileProgram(program);	3,006✔
92	assert(compiled.rules.length === 0);	3,006✔
93	cache.set(cacheKey, compiled);	3,006✔
94	} catch(e) {
95	console.error(`Failed to compile program: ` + e.message);	×
96	console.error(program.prettyprint());	×
97	throw e;	×
98	}
99	return compiled;	3,006✔
100	}
101
102	async simulate(stmt : Ast.ExpressionStatement, compiled : Runtime.CompiledProgram) : Promise<ExecutionResult> {
103	const results : Ast.DialogueHistoryResultItem[] = [];	8,581✔
104	const rawResults : RawExecutionResult = [];	8,581✔
105	let error : Ast.Value\|null = null;	8,581✔
106	const generator = new ResultGenerator(this._rng, this._overrides);	8,581✔
107	for (const slot of stmt.iterateSlots2()) {	8,581✔
108	if (slot instanceof Ast.DeviceSelector)	33,704✔
109	continue;	9,337✔
110	generator.addCandidate(slot.get());	24,367✔
111	}
112	this._execEnv.generator = generator;	8,581✔
113
114	this._execEnv.setOutputDelegate({	8,581✔
115	output: async (outputType : string, outputValue : { [key : string] : unknown }) => {
116	const mapped = new Ast.DialogueHistoryResultItem(null, await this._mapResult(outputType, outputValue));	195,832✔
117	results.push(mapped);	195,832✔
118	rawResults.push([outputType, outputValue]);	195,832✔
119	},
120	error: (err) => {
121	if (!(err instanceof SimulatedError)) {	2,512!
122	console.error(`Failed to execute program`);	×
123	console.error(err);	×
124	console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());	×
125	process.exit(1);	×
126	return;	×
127	}
128	if (err.code)	2,512✔
129	error = new Ast.Value.Enum(err.code);	2,033✔
130	else
131	error = new Ast.Value.String(err.message);	479✔
132	}
133	});
134
135	try {	8,581✔
136	assert(typeof compiled.command === 'function');	8,581✔
137	await compiled.command(this._execEnv);	8,581✔
138	} catch(e) {
139	console.error(`Failed to execute program: ` + e.message);	×
140	console.error(new Ast.Program(null, [], [], [stmt]).prettyprint());	×
141	throw e;	×
142	}
143
144	const numResults = results.length;	8,581✔
145	return [new Ast.DialogueHistoryResultList(null, results.slice(0, PAGE_SIZE),	8,581✔
146	new Ast.Value.Number(Math.min(MORE_SIZE, numResults)), numResults > MORE_SIZE, error), rawResults];
147	}
148
149	private _inferType(key : string, jsValue : unknown) : Type {
150	if (key === 'distance') // HACK	35,469!
UNCOV 151	return new Type.Measure('m');	×
152	if (key === '__device')	35,469✔
153	return new Type.Entity('tt:device_id');	35,172✔
154	if (typeof jsValue === 'boolean')	297!
155	return Type.Boolean;	×
156	if (typeof jsValue === 'string')	297!
157	return Type.String;	×
158	if (typeof jsValue === 'number')	297!
159	return Type.Number;	297✔
160	if (jsValue instanceof Builtin.Currency)	×
161	return Type.Currency;	×
162	if (jsValue instanceof Builtin.Entity)	×
163	return new Type.Entity('');	×
164	if (jsValue instanceof Builtin.Time)	×
165	return Type.Time;	×
166	if (jsValue instanceof Date)	×
167	return Type.Date;	×
168	if (Array.isArray(jsValue) && jsValue.length > 0)	×
169	return new Type.Array(this._inferType(key, jsValue[0]));	×
170	if (Array.isArray(jsValue))	×
171	return new Type.Array(Type.Any);	×
172
173	return Type.Any;	×
174	}
175
176	private _outputTypeToSchema(outputType : string) : Promise<Ast.FunctionDef> {
177	const [kind, fname] = outputType.split(':');	195,711✔
178	let ftype : 'query'\|'action' = 'query';	195,711✔
179
180	let fname_ = fname;	195,711✔
181	if (fname_.startsWith('action/')) {	195,711✔
182	ftype = 'action';	17,709✔
183	fname_ = fname_.substring('action/'.length);	17,709✔
184	}
185	return this._schemas.getSchemaAndNames(kind, ftype, fname_);	195,711✔
186	}
187
188	private async _mapResult(outputType : string\|null, outputValue : { [key : string] : unknown }) : Promise<{ [key : string] : Ast.Value }> {
189	const mappedResult : { [key : string] : Ast.Value } = {};	195,832✔
190	if (outputType === null) {	195,832!
191	// fallback
192	for (const key in outputValue) {	×
193	const jsValue = outputValue[key];	×
194	mappedResult[key] = Ast.Value.fromJS(this._inferType(key, jsValue), jsValue);	×
195	}
196	return mappedResult;	×
197	}
198
199	if (outputType.indexOf('+') >= 0) {	195,832!
200	const types = outputType.split('+');	×
201	outputType = types[types.length-1];	×
202	}
203
204	const aggregation = /^([a-zA-Z]+)\(([^)]+)\)$/.exec(outputType);	195,832✔
205	if (aggregation !== null) {	195,832✔
206	let operator;
207	[, operator, outputType] = aggregation;	121✔
208
209	const field = Object.keys(outputValue)[0];	121✔
210	const value = outputValue[field];	121✔
211	if (operator === 'count') {	121!
212	mappedResult[field] = Ast.Value.fromJS(Type.Number, outputValue[field]);	121✔
213	return mappedResult;	121✔
214	}
215
216	const schema = await this._outputTypeToSchema(outputType);	×
217	const type = schema.getArgType(field) \|\| this._inferType(field, value);	×
218	mappedResult[field] = Ast.Value.fromJS(type, value);	×
219	} else {
220	const schema = await this._outputTypeToSchema(outputType);	195,711✔
221
222	for (const key in outputValue) {	195,711✔
223	const value = outputValue[key];	953,519✔
224	if (value === null \|\| value === undefined)	953,519!
225	continue;	×
226	const type = schema.getArgType(key) \|\| this._inferType(key, value);	953,519✔
227	if (type instanceof Type.Compound)	953,519!
228	mappedResult[key] = this._mapCompound(key + '.', schema, value as { [key : string] : unknown });	×
229	else
230	mappedResult[key] = Ast.Value.fromJS(type, value);	953,519✔
231	}
232	}
233	return mappedResult;	195,711✔
234	}
235
236	private _mapCompound(prefix : string, schema : Ast.FunctionDef, object : { [key : string] : unknown }) : Ast.Value {
237	const result : { [key : string] : Ast.Value } = {};	×
238	for (const key in object) {	×
239	const value = object[key];	×
240	const type = schema.getArgType(prefix + key) \|\| this._inferType(key, value);	×
241	if (type instanceof Type.Compound)	×
242	result[key] = this._mapCompound(prefix + key + '.', schema, object as { [key : string] : unknown });	×
243	else
244	result[key] = Ast.Value.fromJS(type, value);	×
245	}
246	return new Ast.Value.Object(result);	×
247	}
248	}
249
250	/**
251	* Simulate the execution of ThingTalk code.
252	*/
253	export default class ThingTalkStatementSimulator {	111✔
254	private _options : SimulatorOptions;
255	private cache : Map<string, Runtime.CompiledProgram>;
256
257	constructor(options : SimulatorOptions) {
258	this._options = options;	4✔
259	this.cache = new Map;	4✔
260	}
261
262	async executeStatement(stmt : Ast.ExpressionStatement,
263	execState : ThingTalkSimulatorState) : Promise<[Ast.DialogueHistoryResultList, RawExecutionResult, undefined, ThingTalkSimulatorState]> {
264	if (stmt.stream) {	9,865✔
265	// nothing to do, this always returns nothing
266	return [new Ast.DialogueHistoryResultList(null, [],	1,284✔
267	new Ast.Value.Number(0), false, null), [], undefined, execState];
268	}
269
270	if (execState === undefined)	8,581✔
271	execState = new ThingTalkSimulatorState(this._options);	3,872✔
272
273	// there is no way around this, we need to compile and run the program!
274	const compiled = await execState.compile(stmt, this.cache);	8,581✔
275	const [resultList, rawResults] = await execState.simulate(stmt, compiled);	8,581✔
276	// ignore the new program record, it doesn't matter at simulation time
277	return [resultList, rawResults, undefined, execState];	8,581✔
278	}
279	}

stanford-oval / genie-toolkit / 2070

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