2182

pending completion

Build # 2182

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

add thingpedia-dir cmdline argument to linter (#683)

Run Details

9977 of 20088 branches covered (49.67%)

Branch coverage included in aggregate %.

1 of 6 new or added lines in 1 file covered. (16.67%)

1 existing line in 1 file now uncovered.

23572 of 39602 relevant lines covered (59.52%)

629968.51 hits per line

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

6.06

/tool/lint-device.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Thingpedia
//
// Copyright 2019-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 * as argparse from 'argparse';
import * as ThingTalk from 'thingtalk';
import * as Tp from 'thingpedia';
import { promises as pfs } from 'fs';

import { splitParams } from '../lib/utils/misc-utils';

import { getConfig, DEFAULT_THINGPEDIA_URL } from './lib/argutils';

const ALLOWED_ARG_METADATA = new Set(['canonical', 'prompt', 'counted_object', 'question']);
const ALLOWED_FUNCTION_METADATA = new Set(['canonical', 'canonical_short', 'confirmation', 'confirmation_remote', 'formatted', 'result', 'on_error']);
const ALLOWED_CLASS_METADATA = new Set(['name', 'description', 'thingpedia_name', 'thingpedia_description', 'canonical', 'help']);
const SUBCATEGORIES = new Set(['service','media','social-network','communication','home','health','data-management']);

function warning(msg : string) {
    console.error(`WARNING: ${msg}`);
}

let _anyError = false;
function error(msg : string) {
    _anyError = true;
    console.error(`ERROR: ${msg}`);
}

function validateMetadata(metadata : Record<string, unknown>, allowed : Set<string>) {
    for (const name of Object.getOwnPropertyNames(metadata)) {
        if (!allowed.has(name))
            warning(`Invalid natural language annotation ${name}`);
    }
}

function parseNewOrOldSyntax(code : string) {
    try {
        return ThingTalk.Syntax.parse(code);
    } catch(e1) {
        if (e1.name !== 'SyntaxError')
            throw e1;
        try {
            const parsed = ThingTalk.Syntax.parse(code, ThingTalk.Syntax.SyntaxType.Legacy);
            warning('WARNING: manifest.tt and dataset.tt use legacy syntax, you should migrate to ThingTalk 2.0');
            return parsed;
        } catch(e2) {
            if (e2.name !== 'SyntaxError')
                throw e2;
            throw e1;
        }
    }
}

class SimplePlatform extends Tp.BasePlatform {
    private _developerKey : string|null;
    private _prefs : Tp.Preferences;

    constructor(developerKey : string|null) {
        super();
        this._developerKey = developerKey;
        this._prefs = new Tp.Helpers.MemoryPreferences();
    }
    get type() {
        return 'simple';
    }
    get locale() {
        return 'en-US';
    }
    get timezone() {
        return 'America/Los_Angeles';
    }
    hasCapability() {
        return false;
    }
    getCapability() {
        return null;
    }
    getSharedPreferences() {
        return this._prefs;
    }
    getDeveloperKey() {
        return this._developerKey;
    }
}


async function loadClassDef(args : any, classCode : string, datasetCode : string) : Promise<[ThingTalk.Ast.ClassDef, ThingTalk.Ast.Dataset]> {
    const platform = new SimplePlatform(args.developer_key);
    const prefs = platform.getSharedPreferences();
    if (args.thingpedia_dir && args.thingpedia_dir.length)
        prefs.set('developer-dir', args.thingpedia_dir);
    const tpClient = new Tp.HttpClient(platform, args.thingpedia_url);
    const schemaRetriever = new ThingTalk.SchemaRetriever(tpClient, null, true);

    let parsed;
    try {
        parsed = await parseNewOrOldSyntax(`${classCode}\n${datasetCode}`).typecheck(schemaRetriever, true);
    } catch(e) {
        if (e.name === 'SyntaxError' && e.location) {
            let lineNumber = e.location.start.line;
            // add 1 for the \n that we add to separate classCode and datasetCode
            console.log(classCode);
            const classLength = 1 + classCode.split('\n').length;
            const fileName = lineNumber > classLength ? 'dataset.tt' : 'manifest.tt';
            // mind the 1-based line numbers...
            lineNumber = lineNumber > classLength ? lineNumber - classLength + 1 : lineNumber;
            throw new Error(`Syntax error in ${fileName} line ${lineNumber}: ${e.message}`);
        } else {
            throw new Error(e.message);
        }
    }

    if (!(parsed instanceof ThingTalk.Ast.Library) || parsed.classes.length !== 1)
        throw new Error("Invalid manifest file: must contain exactly one class, with the same identifier as the device");
    const classDef = parsed.classes[0];

    if (parsed.datasets.length > 1 || (parsed.datasets.length > 0 && parsed.datasets[0].name !== parsed.classes[0].kind))
        error("Invalid dataset file: must contain exactly one dataset, with the same identifier as the class");
    const dataset = parsed.datasets.length > 0 ? parsed.datasets[0] :
        new ThingTalk.Ast.Dataset(null, parsed.classes[0].kind, [], {});

    return [classDef, dataset];
}

function validateDevice(classDef : ThingTalk.Ast.ClassDef) {
    if (!classDef.metadata.thingpedia_name)
        warning(`Missing required class annotation #_[thingpedia_name]`);
    if (!classDef.metadata.thingpedia_description)
        warning(`Missing required class annotation #_[thingpedia_description]`);

    for (const annot of ['license', 'license_gplcompatible', 'subcategory']) {
        if (!classDef.annotations[annot]) {
            warning(`Missing required class annotation #[${annot}]`);
            continue;
        }

        if (annot === 'subcategory') {
            const value = classDef.annotations[annot].toJS() as string;
            if (!SUBCATEGORIES.has(value))
                error(`Invalid device category ${value}`);
        }
    }

    validateMetadata(classDef.metadata, ALLOWED_CLASS_METADATA);

    if (!classDef.is_abstract) {
        if (!classDef.loader)
            error("loader mixin missing from class declaration");
        if (!classDef.config)
            classDef.imports.push(new ThingTalk.Ast.MixinImportStmt(null, ['config'], 'org.thingpedia.config.none', []));
    }

    validateAllInvocations(classDef, {
        checkPollInterval: !classDef.is_abstract,
    });
}

function validateDataset(dataset : ThingTalk.Ast.Dataset, kind : string) {
    const names = new Set;
    dataset.examples.forEach((ex, i) => {
        try {
            let foundOurDevice = false;
            for (const [, prim] of ex.iteratePrimitives(false)) {
                if (prim.selector.kind === kind) {
                    foundOurDevice = true;
                    break;
                }
            }
            if (!foundOurDevice)
                warning(`Example ${i+1} does not use any function from this device`);

            // validate placeholders in all utterances
            if (ex.utterances.length === 0) {
                if (Object.prototype.hasOwnProperty.call(ex.annotations, 'utterances'))
                    throw new Error(`utterances must be a natural language annotation (with #_[]), not an implementation annotation`);
                else
                    throw new Error(`missing utterances annotation`);
            }

            if (ex.annotations.name) {
                const name = ex.annotations.name.toJS();
                if (typeof name !== 'string')
                    throw new Error(`invalid #[name] annotation (must be a string)`);
                if (name.length > 128)
                    throw new Error(`the #[name] annotation must be at most 128 characters`);
                if (names.has(name))
                    throw new Error(`duplicate name`);
                names.add(name);
            }

            for (const utterance of ex.utterances)
                validateUtterance(ex.args, utterance);
        } catch(e) {
            error(`Error in example ${i+1}: ${e.message}`);
        }
    });
}

function validateUtterance(args : Record<string, ThingTalk.Type>, utterance : string) {
    if (/_{4}/.test(utterance))
        throw new Error('Do not use blanks (4 underscores or more) in utterance, use placeholders');

    const placeholders = new Set;
    for (const chunk of splitParams(utterance.trim())) {
        if (chunk === '')
            continue;
        if (typeof chunk === 'string')
            continue;

        const [match, param1, param2, opt] = chunk;
        if (match === '$$')
            continue;
        const param = param1 || param2;
        if (!(param in args))
            throw new Error(`Invalid placeholder ${param}`);
        if (opt && opt !== 'const' && opt !== 'no-undefined')
            throw new Error(`Invalid placeholder option ${opt} for ${param}`);
        placeholders.add(param);
    }

    for (const arg in args) {
        if (!placeholders.has(arg))
            throw new Error(`Missing placeholder for argument ${arg}`);
    }
}

function validateAllInvocations(classDef : ThingTalk.Ast.ClassDef, options : { checkPollInterval ?: boolean } = {}) {
    const entities = new Set<string>();
    const stringTypes = new Set<string>();
    validateInvocation(classDef.kind, classDef.actions, 'action', entities, stringTypes, options);
    validateInvocation(classDef.kind, classDef.queries, 'query', entities, stringTypes, options);
    return [Array.from(entities), Array.from(stringTypes)];
}

function validateInvocation(kind : string,
                            where : Record<string, ThingTalk.Ast.FunctionDef>,
                            what : 'action'|'query',
                            entities : Set<string>,
                            stringTypes : Set<string>,
                            options : { checkPollInterval ?: boolean } = {}) {
    for (const name in where) {
        const fndef = where[name];

        validateMetadata(fndef.metadata, ALLOWED_FUNCTION_METADATA);

        if (fndef.annotations.confirm) {
            if (fndef.annotations.confirm.isEnum) {
                if (!['confirm', 'auto', 'display_result'].includes(fndef.annotations.confirm.toJS() as string))
                    error(`Invalid #[confirm] annotation for ${name}, must be a an enum "confirm", "auto", "display_result"`);
            } else if (!where[name].annotations.confirm.isBoolean) {
                error(`Invalid #[confirm] annotation for ${name}, must be a Boolean`);
            }
        }
        if (options.checkPollInterval && what === 'query' && where[name].is_monitorable) {
            if (!fndef.annotations.poll_interval)
                error(`Missing poll interval for monitorable query ${name}`);
            else if (fndef.annotations.poll_interval.toJS() as number < 0)
                error(`Invalid negative poll interval for monitorable query ${name}`);
        }

        for (const argname of where[name].args) {
            const arg = fndef.getArgument(argname)!;
            let type = arg.type;
            while (type instanceof ThingTalk.Type.Array)
                type = type.elem as ThingTalk.Type;
            validateMetadata(arg.metadata, ALLOWED_ARG_METADATA);

            if (type instanceof ThingTalk.Type.Entity) {
                entities.add(type.type);
                if (arg.annotations['string_values'])
                    stringTypes.add(arg.annotations['string_values'].toJS() as string);
            } else if (type.isString) {
                if (arg.annotations['string_values'])
                    stringTypes.add(arg.annotations['string_values'].toJS() as string);
            } else {
                if (arg.annotations['string_values'])
                    error('The string_values annotation is valid only for String-typed parameters');
            }
        }
    }
}

export function initArgparse(subparsers : argparse.SubParser) {
    const parser = subparsers.add_parser('lint-device', {
        add_help: true,
        description: "Check the manifest for a Thingpedia device."
    });
    parser.add_argument('--thingpedia-url', {
        required: false,
        help: `base URL of Thingpedia server to contact; defaults to '${DEFAULT_THINGPEDIA_URL}'`
    });
    parser.add_argument('--developer-key', {
        required: false,
        default: '',
        help: `developer key to use when contacting Thingpedia`
    });
    parser.add_argument('--manifest', {
        required: true,
        help: "ThingTalk class definition file."
    });
    parser.add_argument('--dataset', {
        required: true,
        help: "ThingTalk dataset file with the class's primitive templates."
    });
    parser.add_argument('--thingpedia-dir', {
        required: false,
        nargs: '+',
        help: 'Path to a directory containing Thingpedia device definitions (overrides --thingpedia-url).'
    });
}

export async function execute(args : any) {
    if (!args.thingpedia_url)
        args.thingpedia_url = await getConfig('thingpedia.url', process.env.THINGPEDIA_URL || DEFAULT_THINGPEDIA_URL);
    if (!args.developer_key)
        args.developer_key = await getConfig('thingpedia.developer-key', process.env.THINGPEDIA_DEVELOPER_KEY || null);

    const manifestCode = await pfs.readFile(args.manifest, { encoding: 'utf8' });
    const datasetCode = await pfs.readFile(args.dataset, { encoding: 'utf8' });

    const [classDef, dataset] = await loadClassDef(args, manifestCode, datasetCode);

    validateDevice(classDef);
    validateDataset(dataset, classDef.kind);

    if (_anyError)
        throw new Error(`Some errors occurred`);
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Thingpedia
4	//
5	// Copyright 2019-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 * as argparse from 'argparse';
22	import * as ThingTalk from 'thingtalk';	90✔
23	import * as Tp from 'thingpedia';	90✔
24	import { promises as pfs } from 'fs';	90✔
25
26	import { splitParams } from '../lib/utils/misc-utils';	90✔
27
28	import { getConfig, DEFAULT_THINGPEDIA_URL } from './lib/argutils';	90✔
29
30	const ALLOWED_ARG_METADATA = new Set(['canonical', 'prompt', 'counted_object', 'question']);	90✔
31	const ALLOWED_FUNCTION_METADATA = new Set(['canonical', 'canonical_short', 'confirmation', 'confirmation_remote', 'formatted', 'result', 'on_error']);	90✔
32	const ALLOWED_CLASS_METADATA = new Set(['name', 'description', 'thingpedia_name', 'thingpedia_description', 'canonical', 'help']);	90✔
33	const SUBCATEGORIES = new Set(['service','media','social-network','communication','home','health','data-management']);	90✔
34
35	function warning(msg : string) {
36	console.error(`WARNING: ${msg}`);	×
37	}
38
39	let _anyError = false;	90✔
40	function error(msg : string) {
41	_anyError = true;	×
42	console.error(`ERROR: ${msg}`);	×
43	}
44
45	function validateMetadata(metadata : Record<string, unknown>, allowed : Set<string>) {
46	for (const name of Object.getOwnPropertyNames(metadata)) {	×
47	if (!allowed.has(name))	×
48	warning(`Invalid natural language annotation ${name}`);	×
49	}
50	}
51
52	function parseNewOrOldSyntax(code : string) {
53	try {	×
54	return ThingTalk.Syntax.parse(code);	×
55	} catch(e1) {
56	if (e1.name !== 'SyntaxError')	×
57	throw e1;	×
58	try {	×
59	const parsed = ThingTalk.Syntax.parse(code, ThingTalk.Syntax.SyntaxType.Legacy);	×
60	warning('WARNING: manifest.tt and dataset.tt use legacy syntax, you should migrate to ThingTalk 2.0');	×
61	return parsed;	×
62	} catch(e2) {
63	if (e2.name !== 'SyntaxError')	×
64	throw e2;	×
65	throw e1;	×
66	}
67	}
68	}
69
70	class SimplePlatform extends Tp.BasePlatform {
71	private _developerKey : string\|null;
72	private _prefs : Tp.Preferences;
73
74	constructor(developerKey : string\|null) {
75	super();	×
76	this._developerKey = developerKey;	×
77	this._prefs = new Tp.Helpers.MemoryPreferences();	×
78	}
79	get type() {
80	return 'simple';	×
81	}
82	get locale() {
83	return 'en-US';	×
84	}
85	get timezone() {
86	return 'America/Los_Angeles';	×
87	}
88	hasCapability() {
89	return false;	×
90	}
91	getCapability() {
92	return null;	×
93	}
94	getSharedPreferences() {
95	return this._prefs;	×
96	}
97	getDeveloperKey() {
98	return this._developerKey;	×
99	}
100	}
101
102
103	async function loadClassDef(args : any, classCode : string, datasetCode : string) : Promise<[ThingTalk.Ast.ClassDef, ThingTalk.Ast.Dataset]> {
NEW 104	const platform = new SimplePlatform(args.developer_key);	×
NEW 105	const prefs = platform.getSharedPreferences();	×
NEW 106	if (args.thingpedia_dir && args.thingpedia_dir.length)	×
NEW 107	prefs.set('developer-dir', args.thingpedia_dir);	×
NEW 108	const tpClient = new Tp.HttpClient(platform, args.thingpedia_url);	×
UNCOV 109	const schemaRetriever = new ThingTalk.SchemaRetriever(tpClient, null, true);	×
110
111	let parsed;
112	try {	×
113	parsed = await parseNewOrOldSyntax(`${classCode}\n${datasetCode}`).typecheck(schemaRetriever, true);	×
114	} catch(e) {
115	if (e.name === 'SyntaxError' && e.location) {	×
116	let lineNumber = e.location.start.line;	×
117	// add 1 for the \n that we add to separate classCode and datasetCode
118	console.log(classCode);	×
119	const classLength = 1 + classCode.split('\n').length;	×
120	const fileName = lineNumber > classLength ? 'dataset.tt' : 'manifest.tt';	×
121	// mind the 1-based line numbers...
122	lineNumber = lineNumber > classLength ? lineNumber - classLength + 1 : lineNumber;	×
123	throw new Error(`Syntax error in ${fileName} line ${lineNumber}: ${e.message}`);	×
124	} else {
125	throw new Error(e.message);	×
126	}
127	}
128
129	if (!(parsed instanceof ThingTalk.Ast.Library) \|\| parsed.classes.length !== 1)	×
130	throw new Error("Invalid manifest file: must contain exactly one class, with the same identifier as the device");	×
131	const classDef = parsed.classes[0];	×
132
133	if (parsed.datasets.length > 1 \|\| (parsed.datasets.length > 0 && parsed.datasets[0].name !== parsed.classes[0].kind))	×
134	error("Invalid dataset file: must contain exactly one dataset, with the same identifier as the class");	×
135	const dataset = parsed.datasets.length > 0 ? parsed.datasets[0] :	×
136	new ThingTalk.Ast.Dataset(null, parsed.classes[0].kind, [], {});
137
138	return [classDef, dataset];	×
139	}
140
141	function validateDevice(classDef : ThingTalk.Ast.ClassDef) {
142	if (!classDef.metadata.thingpedia_name)	×
143	warning(`Missing required class annotation #_[thingpedia_name]`);	×
144	if (!classDef.metadata.thingpedia_description)	×
145	warning(`Missing required class annotation #_[thingpedia_description]`);	×
146
147	for (const annot of ['license', 'license_gplcompatible', 'subcategory']) {	×
148	if (!classDef.annotations[annot]) {	×
149	warning(`Missing required class annotation #[${annot}]`);	×
150	continue;	×
151	}
152
153	if (annot === 'subcategory') {	×
154	const value = classDef.annotations[annot].toJS() as string;	×
155	if (!SUBCATEGORIES.has(value))	×
156	error(`Invalid device category ${value}`);	×
157	}
158	}
159
160	validateMetadata(classDef.metadata, ALLOWED_CLASS_METADATA);	×
161
162	if (!classDef.is_abstract) {	×
163	if (!classDef.loader)	×
164	error("loader mixin missing from class declaration");	×
165	if (!classDef.config)	×
166	classDef.imports.push(new ThingTalk.Ast.MixinImportStmt(null, ['config'], 'org.thingpedia.config.none', []));	×
167	}
168
169	validateAllInvocations(classDef, {	×
170	checkPollInterval: !classDef.is_abstract,
171	});
172	}
173
174	function validateDataset(dataset : ThingTalk.Ast.Dataset, kind : string) {
175	const names = new Set;	×
176	dataset.examples.forEach((ex, i) => {	×
177	try {	×
178	let foundOurDevice = false;	×
179	for (const [, prim] of ex.iteratePrimitives(false)) {	×
180	if (prim.selector.kind === kind) {	×
181	foundOurDevice = true;	×
182	break;	×
183	}
184	}
185	if (!foundOurDevice)	×
186	warning(`Example ${i+1} does not use any function from this device`);	×
187
188	// validate placeholders in all utterances
189	if (ex.utterances.length === 0) {	×
190	if (Object.prototype.hasOwnProperty.call(ex.annotations, 'utterances'))	×
191	throw new Error(`utterances must be a natural language annotation (with #_[]), not an implementation annotation`);	×
192	else
193	throw new Error(`missing utterances annotation`);	×
194	}
195
196	if (ex.annotations.name) {	×
197	const name = ex.annotations.name.toJS();	×
198	if (typeof name !== 'string')	×
199	throw new Error(`invalid #[name] annotation (must be a string)`);	×
200	if (name.length > 128)	×
201	throw new Error(`the #[name] annotation must be at most 128 characters`);	×
202	if (names.has(name))	×
203	throw new Error(`duplicate name`);	×
204	names.add(name);	×
205	}
206
207	for (const utterance of ex.utterances)	×
208	validateUtterance(ex.args, utterance);	×
209	} catch(e) {
210	error(`Error in example ${i+1}: ${e.message}`);	×
211	}
212	});
213	}
214
215	function validateUtterance(args : Record<string, ThingTalk.Type>, utterance : string) {
216	if (/_{4}/.test(utterance))	×
217	throw new Error('Do not use blanks (4 underscores or more) in utterance, use placeholders');	×
218
219	const placeholders = new Set;	×
220	for (const chunk of splitParams(utterance.trim())) {	×
221	if (chunk === '')	×
222	continue;	×
223	if (typeof chunk === 'string')	×
224	continue;	×
225
226	const [match, param1, param2, opt] = chunk;	×
227	if (match === '$$')	×
228	continue;	×
229	const param = param1 \|\| param2;	×
230	if (!(param in args))	×
231	throw new Error(`Invalid placeholder ${param}`);	×
232	if (opt && opt !== 'const' && opt !== 'no-undefined')	×
233	throw new Error(`Invalid placeholder option ${opt} for ${param}`);	×
234	placeholders.add(param);	×
235	}
236
237	for (const arg in args) {	×
238	if (!placeholders.has(arg))	×
239	throw new Error(`Missing placeholder for argument ${arg}`);	×
240	}
241	}
242
243	function validateAllInvocations(classDef : ThingTalk.Ast.ClassDef, options : { checkPollInterval ?: boolean } = {}) {	×
244	const entities = new Set<string>();	×
245	const stringTypes = new Set<string>();	×
246	validateInvocation(classDef.kind, classDef.actions, 'action', entities, stringTypes, options);	×
247	validateInvocation(classDef.kind, classDef.queries, 'query', entities, stringTypes, options);	×
248	return [Array.from(entities), Array.from(stringTypes)];	×
249	}
250
251	function validateInvocation(kind : string,
252	where : Record<string, ThingTalk.Ast.FunctionDef>,
253	what : 'action'\|'query',
254	entities : Set<string>,
255	stringTypes : Set<string>,
256	options : { checkPollInterval ?: boolean } = {}) {	×
257	for (const name in where) {	×
258	const fndef = where[name];	×
259
260	validateMetadata(fndef.metadata, ALLOWED_FUNCTION_METADATA);	×
261
262	if (fndef.annotations.confirm) {	×
263	if (fndef.annotations.confirm.isEnum) {	×
264	if (!['confirm', 'auto', 'display_result'].includes(fndef.annotations.confirm.toJS() as string))	×
265	error(`Invalid #[confirm] annotation for ${name}, must be a an enum "confirm", "auto", "display_result"`);	×
266	} else if (!where[name].annotations.confirm.isBoolean) {	×
267	error(`Invalid #[confirm] annotation for ${name}, must be a Boolean`);	×
268	}
269	}
270	if (options.checkPollInterval && what === 'query' && where[name].is_monitorable) {	×
271	if (!fndef.annotations.poll_interval)	×
272	error(`Missing poll interval for monitorable query ${name}`);	×
273	else if (fndef.annotations.poll_interval.toJS() as number < 0)	×
274	error(`Invalid negative poll interval for monitorable query ${name}`);	×
275	}
276
277	for (const argname of where[name].args) {	×
278	const arg = fndef.getArgument(argname)!;	×
279	let type = arg.type;	×
280	while (type instanceof ThingTalk.Type.Array)	×
281	type = type.elem as ThingTalk.Type;	×
282	validateMetadata(arg.metadata, ALLOWED_ARG_METADATA);	×
283
284	if (type instanceof ThingTalk.Type.Entity) {	×
285	entities.add(type.type);	×
286	if (arg.annotations['string_values'])	×
287	stringTypes.add(arg.annotations['string_values'].toJS() as string);	×
288	} else if (type.isString) {	×
289	if (arg.annotations['string_values'])	×
290	stringTypes.add(arg.annotations['string_values'].toJS() as string);	×
291	} else {
292	if (arg.annotations['string_values'])	×
293	error('The string_values annotation is valid only for String-typed parameters');	×
294	}
295	}
296	}
297	}
298
299	export function initArgparse(subparsers : argparse.SubParser) {	90✔
300	const parser = subparsers.add_parser('lint-device', {	90✔
301	add_help: true,
302	description: "Check the manifest for a Thingpedia device."
303	});
304	parser.add_argument('--thingpedia-url', {	90✔
305	required: false,
306	help: `base URL of Thingpedia server to contact; defaults to '${DEFAULT_THINGPEDIA_URL}'`
307	});
308	parser.add_argument('--developer-key', {	90✔
309	required: false,
310	default: '',
311	help: `developer key to use when contacting Thingpedia`
312	});
313	parser.add_argument('--manifest', {	90✔
314	required: true,
315	help: "ThingTalk class definition file."
316	});
317	parser.add_argument('--dataset', {	90✔
318	required: true,
319	help: "ThingTalk dataset file with the class's primitive templates."
320	});
321	parser.add_argument('--thingpedia-dir', {	90✔
322	required: false,
323	nargs: '+',
324	help: 'Path to a directory containing Thingpedia device definitions (overrides --thingpedia-url).'
325	});
326	}
327
328	export async function execute(args : any) {	90✔
329	if (!args.thingpedia_url)	×
330	args.thingpedia_url = await getConfig('thingpedia.url', process.env.THINGPEDIA_URL \|\| DEFAULT_THINGPEDIA_URL);	×
331	if (!args.developer_key)	×
332	args.developer_key = await getConfig('thingpedia.developer-key', process.env.THINGPEDIA_DEVELOPER_KEY \|\| null);	×
333
334	const manifestCode = await pfs.readFile(args.manifest, { encoding: 'utf8' });	×
335	const datasetCode = await pfs.readFile(args.dataset, { encoding: 'utf8' });	×
336
337	const [classDef, dataset] = await loadClassDef(args, manifestCode, datasetCode);	×
338
339	validateDevice(classDef);	×
340	validateDataset(dataset, classDef.kind);	×
341
342	if (_anyError)	×
343	throw new Error(`Some errors occurred`);	×
344	}

stanford-oval / genie-toolkit / 2182

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