1109

pending completion

Build # 1109

Build Type

Pull #267

travis-ci-com

Committed by

web-flow

Commit Message

Merge 1720c311b into 7ddbab0b2

Pull Request Pull Request #267: Second PR of TypeScript conversion

Run Details

4328 of 5868 branches covered (73.76%)

Branch coverage included in aggregate %.

216 of 261 new or added lines in 15 files covered. (82.76%)

47 existing lines in 4 files now uncovered.

8943 of 10740 relevant lines covered (83.27%)

1649.71 hits per line

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

81.82

/lib/schema.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2016-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 Type from './type';
import * as Grammar from './grammar_api';
import { typeCheckClass } from './typecheck';
import { ClassDef } from './ast/class_def';
import {
    FunctionDef,
    ArgumentDef,
    ArgDirection
} from './ast/function_def';
import { Library } from './ast/program';
import type { FormatSpec } from './runtime/formatter';

import Cache from './cache';

function delay(timeout : number) : Promise<void> {
    return new Promise((resolve, reject) => {
        setTimeout(resolve, timeout);
    });
}

interface MemoryTable {
    args : string[];
    types : Type[];
}

interface TpMixinDeclaration {
    kind : string;
    types : string[];
    args : string[];
    required : boolean[];
    is_input : boolean[];
    facets : string[];
}
interface MixinDeclaration {
    kind : string;
    types : Type[];
    args : string[];
    required : boolean[];
    is_input : boolean[];
    facets : string[];
}

/**
 * A delegate object to access tables stored in long-term assistant memory.
 *
 * @name MemoryClient
 * @interface
 * @deprecated Long-term memory support in Almond is still experimental and APIs will change
 */
interface MemoryClient {
    /**
     * Retrieve the type information of a stored table
     *
     * @name MemoryClient#getSchema
     * @method
     * @param {string} table - the name of the table to retrieve
     * @return {Object}
     */
    getSchema(table : string, principal : string|null) : Promise<MemoryTable|null>;
}

/**
 * The abstract interface to access Thingpedia.
 *
 * This is the minimal interface needed by the ThingTalk library. It is usally
 * implemented by the Thingpedia SDK.
 */
interface AbstractThingpediaClient {
    /**
     * Retrieve the full code of a Thingpedia class.
     *
     * @param {string} kind - the Thingpedia class identifier
     * @return {string} - the raw code of the class
     */
    getDeviceCode(kind : string) : Promise<string>;

    /**
     * Retrieve type and metadata information for one or more Thingpedia classes.
     *
     * @param {string[]} kinds - the Thingpedia class identifiers to retrieve
     * @param {boolean} getMeta - whether to retrieve metadata or not
     * @return {string} - the retrieved type information, as ThingTalk classes
     */
    getSchemas(kinds : string[], getMeta : boolean) : Promise<string>;

    getMixins() : Promise<{ [key : string] : TpMixinDeclaration }>;
}

class DummyMemoryClient {
    _tables : Map<string, MemoryTable>

    constructor() {
        this._tables = new Map;
    }

    getSchema(table : string, principal : string|null) : Promise<MemoryTable|null> {
        return Promise.resolve(this._tables.get(table) || null);
    }

    createTable(table : string, args : string[], types : Type[]) : Promise<void> {
        this._tables.set(table, { args: args, types: types });
        return Promise.resolve();
    }
}

type FunctionType = 'query' | 'action';

type MetadataLevel = 'basic' | 'everything';

type ClassMap = { [key : string] : ClassDef|Error };

/**
 * Delegate object to retrieve type information and metadata from Thingpedia.
 *
 * This class wraps an {@link AbstractThingpediaClient} and provides batching, in-memory
 * caching, and parsing.
 */
export default class SchemaRetriever {
    private _manifestCache : Map<string, Promise<ClassDef>>;
    private _currentRequest : {
        basic : Promise<ClassMap>|null;
        everything : Promise<ClassMap>|null;
    };
    private _pendingRequests : {
        basic : string[];
        everything : string[];
    };
    private _classCache : {
        basic : Cache<string, ClassDef|null>;
        everything : Cache<string, ClassDef|null>;
    };

    private _thingpediaClient : AbstractThingpediaClient;
    private _memoryClient : MemoryClient;
    private _silent : boolean;

    /**
     * Construct a new schema retriever.
     *
     * @param {AbstractThingpediaClient} tpClient - the Thingpedia client interface to wrap
     * @param {MemoryClient} [mClient] - the client interface to access stored tables
     * @param {boolean} [silent=false] - whether debugging information should be printed
     */
    constructor(tpClient : AbstractThingpediaClient,
                mClient : MemoryClient,
                silent = false) {
        this._manifestCache = new Map;

        // each of the following exists for schema (types only)
        // and metadata (types and NL annotations)
        // keyed by isMeta/useMeta
        this._currentRequest = {
            basic: null,
            everything: null
        };
        this._pendingRequests = {
            basic: [],
            everything: []
        };
        this._classCache = {
            // expire class caches in 24 hours (same as on-disk thingpedia caches)
            basic: new Cache(24 * 3600 * 1000),
            everything: new Cache(24 * 3600 * 1000)
        };

        this._thingpediaClient = tpClient;
        this._memoryClient = mClient || new DummyMemoryClient();
        this._silent = !!silent;
    }

    /**
     * Remove all information related to the given Thingpedia class from the cache.
     *
     * @param {string} kind - the class identifier
     */
    removeFromCache(kind : string) : void {
        this._classCache.basic.delete(kind);
        this._classCache.everything.delete(kind);
        this._manifestCache.delete(kind);
    }
    /**
     * Remove all information from all caches.
     */
    clearCache() : void {
        this._classCache.basic.clear();
        this._classCache.everything.clear();
        this._manifestCache.clear();
    }

    /**
     * Override cached type information with the passed in class.
     *
     * This can be used to ensure the schema retriever is consistent with other
     * cached information (for example, on disk caching of device implementation).
     *
     * @param {Ast.ClassDef} classDef - class definition to inject
     */
    injectClass(classDef : ClassDef) : void {
        // never expire explicitly injected class
        this._classCache.basic.set(classDef.kind, classDef, -1);
        this._classCache.everything.set(classDef.kind, classDef, -1);
        this._manifestCache.set(classDef.kind, Promise.resolve(classDef));
    }

    private async _getManifestRequest(kind : string) {
        const code = await this._thingpediaClient.getDeviceCode(kind);
        const parsed = await Grammar.parseAndTypecheck(code, this);
        assert(parsed instanceof Library && parsed.classes.length > 0);
        return parsed.classes[0];
    }

    private _getManifest(kind : string) : Promise<ClassDef> {
        if (this._manifestCache.has(kind))
            return Promise.resolve(this._manifestCache.get(kind) as Promise<ClassDef>);

        const request = this._getManifestRequest(kind);
        this._manifestCache.set(kind, request);
        return request;
    }

    async getFormatMetadata(kind : string, query : string) : Promise<FormatSpec> {
        const classDef = await this._getManifest(kind);
        if (classDef.queries[query])
            return (classDef.queries[query].metadata.formatted as FormatSpec) || [];
        return [];
    }

    private async _makeRequest(isMeta : MetadataLevel) : Promise<ClassMap> {
        // delay the actual request so that further requests
        // in the same event loop iteration will be batched
        // toghether
        // batching is important because otherwise we can
        // make a lot of tiny HTTP requests at the same time
        // and kill the Thingpedia server just out of overhead
        await delay(0);

        const pending = this._pendingRequests[isMeta];
        this._pendingRequests[isMeta] = [];
        this._currentRequest[isMeta] = null;
        if (pending.length === 0)
            return {};
        if (!this._silent)
            console.log(`Batched ${isMeta ? 'schema-meta' : 'schema'} request for ${pending}`);
        const code = await this._thingpediaClient.getSchemas(pending, isMeta === 'everything');

        const parsed = Grammar.parse(code) as Library;
        const result : ClassMap = {};
        if (!parsed)
            return result;

        const missing = new Set<string>(pending);

        await Promise.all(parsed.classes.map(async (classDef) => {
            try {
                await typeCheckClass(classDef, this, {}, isMeta, true);
                this._classCache[isMeta].set(classDef.kind, classDef);
                result[classDef.kind] = classDef;
                missing.delete(classDef.kind);
            } catch(e) {
                result[classDef.kind] = e;
            }
        }));
        // add negative cache entry (with small 10 minute timeout) for the missing class
        for (const kind of missing) {
            // we add it for both with & without metadata (if the class doesn't exist it doesn't exist)
            this._classCache.basic.set(kind, null, 600 * 1000);
            this._classCache.everything.set(kind, null, 600 * 1000);
        }

        return result;
    }

    private _ensureRequest(isMeta : MetadataLevel) : void {
        if (this._currentRequest[isMeta] !== null)
            return;
        this._currentRequest[isMeta] = this._makeRequest(isMeta);
    }

    private async _getClass(kind : string, useMeta : MetadataLevel) : Promise<ClassDef> {
        if (typeof kind !== 'string')
            throw new TypeError();
        const cached = this._classCache[useMeta].get(kind);
        if (cached !== undefined) {
            if (cached === null) // negative cache
                throw new TypeError('Invalid kind ' + kind);
            return cached;
        }

        if (this._pendingRequests[useMeta].indexOf(kind) < 0)
            this._pendingRequests[useMeta].push(kind);
        this._ensureRequest(useMeta);
        const everything = await (this._currentRequest[useMeta] as Promise<ClassMap>);

        if (kind in everything) {
            const result = everything[kind];
            if (result instanceof Error)
                throw result;
            else
                return result;
        } else {
            throw new TypeError('Invalid kind ' + kind);
        }
    }

    /**
     * Return the full type information of the passed in class.
     *
     * @param {string} kind - the class identifier
     * @return {Ast.ClassDef} the corresponding class
     * @async
     */
    getFullSchema(kind : string) : Promise<ClassDef> {
        return this._getClass(kind, 'everything');
    }
    /**
     * Return the full type information and metadata of the passed in class.
     *
     * @param {string} kind - the class identifier
     * @return {Ast.ClassDef} the corresponding class, including metadata
     * @async
     */
    getFullMeta(kind : string) : Promise<ClassDef> {
        return this._getClass(kind, 'everything');
    }

    private _where(where : FunctionType) : ('queries'|'actions') {
        switch (where) {
            case 'query': return 'queries';
            case 'action': return 'actions';
            default: throw new TypeError('unexpected function type ' + where);
        }
    }

    // FIXME: this function exists for compatibility with
    // some really old code in almond-cloud (IIRC)
    // investigate if it can be removed

    /**
     * Return the type signature of the given function.
     *
     * This method is deprecated because it returns the types without the
     * argument names, directions and annotations.
     *
     * @param {string} kind - the class identifier
     * @param {string} functionType - the type of function (either `query` or `action`)
     * @param {string} name - the function name
     * @return {Type[]} the list of types in the signature
     * @deprecated Use {@link SchemaRetriever#getSchemaAndNames} instead
     * @async
     */
    async getSchema(kind : string,
                    functionType : FunctionType,
                    name : string) : Promise<Type[]> {
        return (await this.getSchemaAndNames(kind, functionType, name)).types;
    }

    private async _getFunction(kind : string,
                               functionType : FunctionType,
                               name : string,
                               useMeta : MetadataLevel) : Promise<FunctionDef> {
        const where = this._where(functionType);
        const classDef = await this._getClass(kind, useMeta);
        if (!(name in classDef[where]))
            throw new TypeError(`Class ${kind} has no ${functionType} ${name}`);
        const fndef = classDef[where][name];
        return fndef;
    }

    /**
     * Return the type information of the given function.
     *
     * This method returns the minimal amount of information necessary to typecheck
     * a program, but not enough to drive the dialog agent.
     * This method is preferred to {@link SchemaRetriever#getMeta} when metadata
     * is not needed, because it reduces the load on the server (which can skip the
     * localization step) and reduces the amount of transferred data.
     *
     * @param {string} kind - the class identifier
     * @param {string} functionType - the type of function (either `query` or `action`)
     * @param {string} name - the function name
     * @return {Ast.FunctionDef} the function definition
     * @async
     */
    getSchemaAndNames(kind : string,
                      functionType : FunctionType,
                      name : string) : Promise<FunctionDef> {
        return this._getFunction(kind, functionType, name, 'basic');
    }

    /**
     * Return the type information and metadata of the given function.
     *
     * This method returns the full amount of information necessary to typecheck
     * and drive the dialog agent, but might not include implementation only information
     * (such as loader or configuration mixins).
     *
     * @param {string} kind - the class identifier
     * @param {string} functionType - the type of function (either `query` or `action`)
     * @param {string} name - the function name
     * @return {Ast.FunctionDef} the function definition
     * @async
     */
    getMeta(kind : string,
            functionType : FunctionType,
            name : string) : Promise<FunctionDef> {
        return this._getFunction(kind, functionType, name, 'everything');
    }

    async getMemorySchema(table : string, getMeta = false) : Promise<FunctionDef> {
        const resolved = await this._memoryClient.getSchema(table, null);
        if (!resolved)
            throw new TypeError(`No such table ${table}`);
        const {args:argnames, types} = resolved;

        const args : ArgumentDef[] = [];
        for (let i = 0; i < types.length; i++)
            args.push(new ArgumentDef(null, ArgDirection.OUT, argnames[i], Type.fromString(types[i])));

        const functionDef = new FunctionDef(null, 'query',
                                            null,
                                            table,
                                            [],
                                            { is_list: true, is_monitorable: true },
                                            args,
                                            {});
        // complete initialization of the function
        functionDef.setClass(null);
        assert(functionDef.minimal_projection);
        return functionDef;
    }

    async getMixins(kind : string) : Promise<MixinDeclaration> {
        const mixins = await this._thingpediaClient.getMixins();
        if (!(kind in mixins))
            throw new TypeError("Mixin " + kind + " not found.");
        const resolved = mixins[kind];

        const parsed : MixinDeclaration = {
            kind: resolved.kind,
            types: resolved.types.map(Type.fromString),
            args: resolved.args,
            required: resolved.required,
            is_input: resolved.is_input,
            facets: resolved.facets
        };
        return parsed;
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2016-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	import assert from 'assert';	2✔
22
23	import Type from './type';	2✔
24	import * as Grammar from './grammar_api';	2✔
25	import { typeCheckClass } from './typecheck';	2✔
26	import { ClassDef } from './ast/class_def';
27	import {	2✔
28	FunctionDef,
29	ArgumentDef,
30	ArgDirection
31	} from './ast/function_def';
32	import { Library } from './ast/program';	2✔
33	import type { FormatSpec } from './runtime/formatter';
34
35	import Cache from './cache';	2✔
36
37	function delay(timeout : number) : Promise<void> {
38	return new Promise((resolve, reject) => {	38✔
39	setTimeout(resolve, timeout);	38✔
40	});
41	}
42
43	interface MemoryTable {
44	args : string[];
45	types : Type[];
46	}
47
48	interface TpMixinDeclaration {
49	kind : string;
50	types : string[];
51	args : string[];
52	required : boolean[];
53	is_input : boolean[];
54	facets : string[];
55	}
56	interface MixinDeclaration {
57	kind : string;
58	types : Type[];
59	args : string[];
60	required : boolean[];
61	is_input : boolean[];
62	facets : string[];
63	}
64
65	/**
66	* A delegate object to access tables stored in long-term assistant memory.
67	*
68	* @name MemoryClient
69	* @interface
70	* @deprecated Long-term memory support in Almond is still experimental and APIs will change
71	*/
72	interface MemoryClient {
73	/**
74	* Retrieve the type information of a stored table
75	*
76	* @name MemoryClient#getSchema
77	* @method
78	* @param {string} table - the name of the table to retrieve
79	* @return {Object}
80	*/
81	getSchema(table : string, principal : string\|null) : Promise<MemoryTable\|null>;
82	}
83
84	/**
85	* The abstract interface to access Thingpedia.
86	*
87	* This is the minimal interface needed by the ThingTalk library. It is usally
88	* implemented by the Thingpedia SDK.
89	*/
90	interface AbstractThingpediaClient {
91	/**
92	* Retrieve the full code of a Thingpedia class.
93	*
94	* @param {string} kind - the Thingpedia class identifier
95	* @return {string} - the raw code of the class
96	*/
97	getDeviceCode(kind : string) : Promise<string>;
98
99	/**
100	* Retrieve type and metadata information for one or more Thingpedia classes.
101	*
102	* @param {string[]} kinds - the Thingpedia class identifiers to retrieve
103	* @param {boolean} getMeta - whether to retrieve metadata or not
104	* @return {string} - the retrieved type information, as ThingTalk classes
105	*/
106	getSchemas(kinds : string[], getMeta : boolean) : Promise<string>;
107
108	getMixins() : Promise<{ [key : string] : TpMixinDeclaration }>;
109	}
110
111	class DummyMemoryClient {
112	_tables : Map<string, MemoryTable>
113
114	constructor() {
115	this._tables = new Map;	26✔
116	}
117
118	getSchema(table : string, principal : string\|null) : Promise<MemoryTable\|null> {
119	return Promise.resolve(this._tables.get(table) \|\| null);	×
120	}
121
122	createTable(table : string, args : string[], types : Type[]) : Promise<void> {
123	this._tables.set(table, { args: args, types: types });	×
124	return Promise.resolve();	×
125	}
126	}
127
128	type FunctionType = 'query' \| 'action';
129
130	type MetadataLevel = 'basic' \| 'everything';
131
132	type ClassMap = { [key : string] : ClassDef\|Error };
133
134	/**
135	* Delegate object to retrieve type information and metadata from Thingpedia.
136	*
137	* This class wraps an {@link AbstractThingpediaClient} and provides batching, in-memory
138	* caching, and parsing.
139	*/
140	export default class SchemaRetriever {	2✔
141	private _manifestCache : Map<string, Promise<ClassDef>>;
142	private _currentRequest : {
143	basic : Promise<ClassMap>\|null;
144	everything : Promise<ClassMap>\|null;
145	};
146	private _pendingRequests : {
147	basic : string[];
148	everything : string[];
149	};
150	private _classCache : {
151	basic : Cache<string, ClassDef\|null>;
152	everything : Cache<string, ClassDef\|null>;
153	};
154
155	private _thingpediaClient : AbstractThingpediaClient;
156	private _memoryClient : MemoryClient;
157	private _silent : boolean;
158
159	/**
160	* Construct a new schema retriever.
161	*
162	* @param {AbstractThingpediaClient} tpClient - the Thingpedia client interface to wrap
163	* @param {MemoryClient} [mClient] - the client interface to access stored tables
164	* @param {boolean} [silent=false] - whether debugging information should be printed
165	*/
166	constructor(tpClient : AbstractThingpediaClient,
167	mClient : MemoryClient,
168	silent = false) {	4✔
169	this._manifestCache = new Map;	40✔
170
171	// each of the following exists for schema (types only)
172	// and metadata (types and NL annotations)
173	// keyed by isMeta/useMeta
174	this._currentRequest = {	40✔
175	basic: null,
176	everything: null
177	};
178	this._pendingRequests = {	40✔
179	basic: [],
180	everything: []
181	};
182	this._classCache = {	40✔
183	// expire class caches in 24 hours (same as on-disk thingpedia caches)
184	basic: new Cache(24 * 3600 * 1000),
185	everything: new Cache(24 * 3600 * 1000)
186	};
187
188	this._thingpediaClient = tpClient;	40✔
189	this._memoryClient = mClient \|\| new DummyMemoryClient();	40✔
190	this._silent = !!silent;	40✔
191	}
192
193	/**
194	* Remove all information related to the given Thingpedia class from the cache.
195	*
196	* @param {string} kind - the class identifier
197	*/
198	removeFromCache(kind : string) : void {
NEW 199	this._classCache.basic.delete(kind);	×
NEW 200	this._classCache.everything.delete(kind);	×
201	this._manifestCache.delete(kind);	×
202	}
203	/**
204	* Remove all information from all caches.
205	*/
206	clearCache() : void {
NEW 207	this._classCache.basic.clear();	×
NEW 208	this._classCache.everything.clear();	×
209	this._manifestCache.clear();	×
210	}
211
212	/**
213	* Override cached type information with the passed in class.
214	*
215	* This can be used to ensure the schema retriever is consistent with other
216	* cached information (for example, on disk caching of device implementation).
217	*
218	* @param {Ast.ClassDef} classDef - class definition to inject
219	*/
220	injectClass(classDef : ClassDef) : void {
221	// never expire explicitly injected class
222	this._classCache.basic.set(classDef.kind, classDef, -1);	4✔
223	this._classCache.everything.set(classDef.kind, classDef, -1);	4✔
224	this._manifestCache.set(classDef.kind, Promise.resolve(classDef));	4✔
225	}
226
227	private async _getManifestRequest(kind : string) {
228	const code = await this._thingpediaClient.getDeviceCode(kind);	16✔
229	const parsed = await Grammar.parseAndTypecheck(code, this);	16✔
230	assert(parsed instanceof Library && parsed.classes.length > 0);	16✔
231	return parsed.classes[0];	16✔
232	}
233
234	private _getManifest(kind : string) : Promise<ClassDef> {
235	if (this._manifestCache.has(kind))	40✔
236	return Promise.resolve(this._manifestCache.get(kind) as Promise<ClassDef>);	24✔
237
238	const request = this._getManifestRequest(kind);	16✔
239	this._manifestCache.set(kind, request);	16✔
240	return request;	16✔
241	}
242
243	async getFormatMetadata(kind : string, query : string) : Promise<FormatSpec> {
244	const classDef = await this._getManifest(kind);	40✔
245	if (classDef.queries[query])	40!
246	return (classDef.queries[query].metadata.formatted as FormatSpec) \|\| [];	40✔
247	return [];	×
248	}
249
250	private async _makeRequest(isMeta : MetadataLevel) : Promise<ClassMap> {
251	// delay the actual request so that further requests
252	// in the same event loop iteration will be batched
253	// toghether
254	// batching is important because otherwise we can
255	// make a lot of tiny HTTP requests at the same time
256	// and kill the Thingpedia server just out of overhead
257	await delay(0);	38✔
258
259	const pending = this._pendingRequests[isMeta];	38✔
260	this._pendingRequests[isMeta] = [];	38✔
261	this._currentRequest[isMeta] = null;	38✔
262	if (pending.length === 0)	38!
263	return {};	×
264	if (!this._silent)	38✔
265	console.log(`Batched ${isMeta ? 'schema-meta' : 'schema'} request for ${pending}`);	2!
266	const code = await this._thingpediaClient.getSchemas(pending, isMeta === 'everything');	38✔
267
268	const parsed = Grammar.parse(code) as Library;	38✔
269	const result : ClassMap = {};	38✔
270	if (!parsed)	38!
271	return result;	×
272
273	const missing = new Set<string>(pending);	38✔
274
275	await Promise.all(parsed.classes.map(async (classDef) => {	38✔
276	try {	3,686✔
277	await typeCheckClass(classDef, this, {}, isMeta, true);	3,686✔
278	this._classCache[isMeta].set(classDef.kind, classDef);	3,686✔
279	result[classDef.kind] = classDef;	3,686✔
280	missing.delete(classDef.kind);	3,686✔
281	} catch(e) {
282	result[classDef.kind] = e;	×
283	}
284	}));
285	// add negative cache entry (with small 10 minute timeout) for the missing class
286	for (const kind of missing) {	38✔
287	// we add it for both with & without metadata (if the class doesn't exist it doesn't exist)
288	this._classCache.basic.set(kind, null, 600 * 1000);	8✔
289	this._classCache.everything.set(kind, null, 600 * 1000);	8✔
290	}
291
292	return result;	38✔
293	}
294
295	private _ensureRequest(isMeta : MetadataLevel) : void {
296	if (this._currentRequest[isMeta] !== null)	70✔
297	return;	32✔
298	this._currentRequest[isMeta] = this._makeRequest(isMeta);	38✔
299	}
300
301	private async _getClass(kind : string, useMeta : MetadataLevel) : Promise<ClassDef> {
302	if (typeof kind !== 'string')	2,072!
303	throw new TypeError();	×
304	const cached = this._classCache[useMeta].get(kind);	2,072✔
305	if (cached !== undefined) {	2,072✔
306	if (cached === null) // negative cache	2,002!
307	throw new TypeError('Invalid kind ' + kind);	×
308	return cached;	2,002✔
309	}
310
311	if (this._pendingRequests[useMeta].indexOf(kind) < 0)	70✔
312	this._pendingRequests[useMeta].push(kind);	56✔
313	this._ensureRequest(useMeta);	70✔
314	const everything = await (this._currentRequest[useMeta] as Promise<ClassMap>);	70✔
315
316	if (kind in everything) {	70✔
317	const result = everything[kind];	62✔
318	if (result instanceof Error)	62!
NEW 319	throw result;	×
320	else
321	return result;	62✔
322	} else {
323	throw new TypeError('Invalid kind ' + kind);	8✔
324	}
325	}
326
327	/**
328	* Return the full type information of the passed in class.
329	*
330	* @param {string} kind - the class identifier
331	* @return {Ast.ClassDef} the corresponding class
332	* @async
333	*/
334	getFullSchema(kind : string) : Promise<ClassDef> {
335	return this._getClass(kind, 'everything');	2✔
336	}
337	/**
338	* Return the full type information and metadata of the passed in class.
339	*
340	* @param {string} kind - the class identifier
341	* @return {Ast.ClassDef} the corresponding class, including metadata
342	* @async
343	*/
344	getFullMeta(kind : string) : Promise<ClassDef> {
NEW 345	return this._getClass(kind, 'everything');	×
346	}
347
348	private _where(where : FunctionType) : ('queries'\|'actions') {
349	switch (where) {	2,150✔
350	case 'query': return 'queries';	1,550!
351	case 'action': return 'actions';	600✔
352	default: throw new TypeError('unexpected function type ' + where);	×
353	}
354	}
355
356	// FIXME: this function exists for compatibility with
357	// some really old code in almond-cloud (IIRC)
358	// investigate if it can be removed
359
360	/**
361	* Return the type signature of the given function.
362	*
363	* This method is deprecated because it returns the types without the
364	* argument names, directions and annotations.
365	*
366	* @param {string} kind - the class identifier
367	* @param {string} functionType - the type of function (either `query` or `action`)
368	* @param {string} name - the function name
369	* @return {Type[]} the list of types in the signature
370	* @deprecated Use {@link SchemaRetriever#getSchemaAndNames} instead
371	* @async
372	*/
373	async getSchema(kind : string,
374	functionType : FunctionType,
375	name : string) : Promise<Type[]> {
376	return (await this.getSchemaAndNames(kind, functionType, name)).types;	×
377	}
378
379	private async _getFunction(kind : string,
380	functionType : FunctionType,
381	name : string,
382	useMeta : MetadataLevel) : Promise<FunctionDef> {
383	const where = this._where(functionType);	2,070✔
384	const classDef = await this._getClass(kind, useMeta);	2,070✔
385	if (!(name in classDef[where]))	2,062✔
386	throw new TypeError(`Class ${kind} has no ${functionType} ${name}`);	4✔
387	const fndef = classDef[where][name];	2,058✔
388	return fndef;	2,058✔
389	}
390
391	/**
392	* Return the type information of the given function.
393	*
394	* This method returns the minimal amount of information necessary to typecheck
395	* a program, but not enough to drive the dialog agent.
396	* This method is preferred to {@link SchemaRetriever#getMeta} when metadata
397	* is not needed, because it reduces the load on the server (which can skip the
398	* localization step) and reduces the amount of transferred data.
399	*
400	* @param {string} kind - the class identifier
401	* @param {string} functionType - the type of function (either `query` or `action`)
402	* @param {string} name - the function name
403	* @return {Ast.FunctionDef} the function definition
404	* @async
405	*/
406	getSchemaAndNames(kind : string,
407	functionType : FunctionType,
408	name : string) : Promise<FunctionDef> {
409	return this._getFunction(kind, functionType, name, 'basic');	1,446✔
410	}
411
412	/**
413	* Return the type information and metadata of the given function.
414	*
415	* This method returns the full amount of information necessary to typecheck
416	* and drive the dialog agent, but might not include implementation only information
417	* (such as loader or configuration mixins).
418	*
419	* @param {string} kind - the class identifier
420	* @param {string} functionType - the type of function (either `query` or `action`)
421	* @param {string} name - the function name
422	* @return {Ast.FunctionDef} the function definition
423	* @async
424	*/
425	getMeta(kind : string,
426	functionType : FunctionType,
427	name : string) : Promise<FunctionDef> {
428	return this._getFunction(kind, functionType, name, 'everything');	624✔
429	}
430
431	async getMemorySchema(table : string, getMeta = false) : Promise<FunctionDef> {	×
432	const resolved = await this._memoryClient.getSchema(table, null);	78✔
433	if (!resolved)	78✔
434	throw new TypeError(`No such table ${table}`);	2✔
435	const {args:argnames, types} = resolved;	76✔
436
437	const args : ArgumentDef[] = [];	76✔
438	for (let i = 0; i < types.length; i++)	76✔
439	args.push(new ArgumentDef(null, ArgDirection.OUT, argnames[i], Type.fromString(types[i])));	474✔
440
441	const functionDef = new FunctionDef(null, 'query',	76✔
442	null,
443	table,
444	[],
445	{ is_list: true, is_monitorable: true },
446	args,
447	{});
448	// complete initialization of the function
449	functionDef.setClass(null);	76✔
450	assert(functionDef.minimal_projection);	76✔
451	return functionDef;	76✔
452	}
453
454	async getMixins(kind : string) : Promise<MixinDeclaration> {
455	const mixins = await this._thingpediaClient.getMixins();	414✔
456	if (!(kind in mixins))	414✔
457	throw new TypeError("Mixin " + kind + " not found.");	2✔
458	const resolved = mixins[kind];	412✔
459
460	const parsed : MixinDeclaration = {	412✔
461	kind: resolved.kind,
462	types: resolved.types.map(Type.fromString),
463	args: resolved.args,
464	required: resolved.required,
465	is_input: resolved.is_input,
466	facets: resolved.facets
467	};
468	return parsed;	412✔
469	}
470	}

stanford-oval / thingtalk / 1109

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