stanford-oval / thingtalk / 715

pending completion

Build # 715

Build Type

Pull #162

travis-ci

Committed by

web-flow

Commit Message

Fix lint

Pull Request Pull Request #162: Extend device selectors to refer to devices by name

Run Details

4139 of 5279 branches covered (78.41%)

Branch coverage included in aggregate %.

105 of 128 new or added lines in 10 files covered. (82.03%)

42 existing lines in 1 file now uncovered.

7164 of 8487 relevant lines covered (84.41%)

1408.03 hits per line

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

75.24

/lib/ast/slots.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2015-2016 The Board of Trustees of the Leland Stanford Junior University
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
//
// See COPYING for details
"use strict";

const assert = require('assert');
const Type = require('../type');
const I18n = require('../i18n');
const { clean } = require('../utils');

const { Value } = require('./values');

/**
 * The abstract representation of a slot.
 *
 * A slot is a placeholder for a value that can be replaced or changed by
 * API user. This API is used to iterate all values (parameters and filters)
 * in a program.
 *
 * @alias Ast~AbstractSlot
 */
class AbstractSlot {
    /**
     * Construct a new abstract slot.
     *
     * @param {module.Ast:Invocation|null} prim - the primitive associated with this slot, if any
     * @param {Object.<string, Ast.ScopeEntry>} scope - available names for parameter passing
     * @protected
     */
    constructor(prim, scope) {
        this._prim = prim;


        this._scope = scope;
        this._options = undefined;
    }

    get primitive() {
        return this._prim;
    }
    get scope() {
        return this._scope;
    }

    // the available options to parameter pass from
    // this is computed lazily because it needs this.type, which
    // is not available in the constructor
    get options() {
        if (this._options)
            return this._options;

        let options = [];
        const slotType = this.type;
        for (var vname in this._scope) {
            let option = this._scope[vname];
            if (Type.isAssignable(option.type, slotType))
                options.push(option);
        }
        return this._options = options;
    }

    /* istanbul ignore next */
    get type() {
        throw new Error('Abstract method');
    }
    /* istanbul ignore next */
    getPrompt(locale) {
        throw new Error('Abstract method');
    }
    /* istanbul ignore next */
    get() {
        throw new Error('Abstract method');
    }
    /* istanbul ignore next */
    set(value) {
        throw new Error('Abstract method');
    }

    isUndefined() {
        return this.get().isUndefined;
    }
    isConcrete() {
        return this.get().isConcrete();
    }
    isCompilable() {
        const value = this.get();
        if (value.isUndefined)
            return false;
        if (!value.isConcrete())
            return false;

        const valueType = value.getType();
        const slotType = this.type;
        if (valueType.isEntity && slotType.isEntity && valueType.type === 'tt:username' && slotType.type !== 'tt:username')
            return false;

        return true;
    }
}

class InputParamSlot extends AbstractSlot {
    constructor(prim, scope, arg, slot) {
        super(prim, scope);
        this._arg = arg;
        this._slot = slot;
    }

    toString() {
        return `InputParamSlot(${this._slot.name} : ${this.type})`;
    }

    get _argcanonical() {
        return this._arg ? this._arg.canonical : clean(this._slot.name);
    }

    get type() {
        if (this._arg)
            return this._arg.type;
        else
            return Type.Any;
    }
    get tag() {
        return `in_param.${this._slot.name}`;
    }
    getPrompt(locale) {
        const gettext = I18n.get(locale);
        if (this._arg && this._arg.metadata.prompt)
            return this._arg.metadata.prompt;

        const canonical = this._argcanonical;
        return gettext.dgettext('thingtalk', "Please tell me the %s.").format(canonical);
    }
    get() {
        return this._slot.value;
    }
    set(value) {
        this._slot.value = value;
    }
}

class DeviceAttributeSlot extends AbstractSlot {
    constructor(prim, attr) {
        super(prim, {});
        this._slot = attr;
        assert(this._slot.name === 'name');
    }

    toString() {
        return `DeviceAttributeSlot(${this._slot.name} : ${this.type})`;
    }

    get type() {
        return Type.String;
    }
    get tag() {
        return `attribute.${this._slot.name}`;
    }
    getPrompt(locale) {
        // this method should never be used, because $? does not typecheck in a device
        // attribute, but we include for completeness, and just in case
        const gettext = I18n.get(locale);
        return gettext.dgettext('thingtalk', "Please tell me the name of the device you would like to use.");
    }
    get() {
        return this._slot.value;
    }
    set(value) {
        this._slot.value = value;
    }
}

class FilterSlot extends AbstractSlot {
    constructor(prim, scope, arg, filter) {
        super(prim && prim.isPermissionRule ? null : prim, scope);

        this._isSourceFilter = prim && prim.isPermissionRule;
        this._arg = arg;
        this._filter = filter;
    }

    toString() {
        return `FilterSlot(${this._filter.name} ${this._filter.operator} : ${this.type})`;
    }

    get _argcanonical() {
        return this._arg ? this._arg.canonical : clean(this._filter.name);
    }

    // overidde the default option handling to filter out non-sensical filters such as "x == x"
    get options() {
        if (this._options)
            return this._options;
        let options = [];

        const slotType = this.type;
        for (var vname in this._scope) {
            let option = this._scope[vname];
            if (Type.isAssignable(option.type, slotType)) {
                if (option.value.isVarRef && option.value.name === this._filter.name &&
                    option._prim === this._prim)
                    continue;
                if (option.value.isEvent)
                    continue;
                options.push(option);
            }
        }
        return this._options = options;
    }

    get type() {
        if (this._isSourceFilter) {
            switch (this._filter.operator) {
            case 'in_array':
                return new Type.Array(Type.Entity('tt:contact'));
            default:
                return Type.Entity('tt:contact');
            }
        } else if (this._arg) {
            switch (this._filter.operator) {
            case 'contains':
                return this._arg.type.elem;
            case 'in_array':
                return new Type.Array(this._arg.type);
            default:
                return this._arg.type;
            }
        } else {
            return Type.Any;
        }
    }
    get tag() {
        return `filter.${this._filter.operator}.${this._isSourceFilter ? '$' : ''}${this._filter.name}`;
    }
    getPrompt(locale) {
        const gettext = I18n.get(locale);
        if (['==', 'contains', 'in_array', '=~'].indexOf(this._filter.operator) >= 0 &&
            this._arg && this._arg.metadata.prompt)
            return this._arg.metadata.prompt;

        if (this._isSourceFilter)
            return gettext.dgettext('thingtalk', "Who is allowed to ask you for this command?");

        const canonical = this._argcanonical;
        switch (this._filter.operator) {
        case '>=':
            return gettext.dgettext('thingtalk', "What should the %s be greater than?").format(canonical);
        case '<=':
            return gettext.dgettext('thingtalk', "What should the %s be less than?").format(canonical);
        case 'starts_with':
            return gettext.dgettext('thingtalk', "How should the %s start with?").format(canonical);
        case 'ends_with':
            return gettext.dgettext('thingtalk', "How should the %s end with?").format(canonical);
        case '=~':
            return gettext.dgettext('thingtalk', "What should the %s contain?").format(canonical);
        case '==':
            return gettext.dgettext('thingtalk', "What should the %s be equal to?").format(canonical);
        default:
            // ugly default but guaranteed to work...
            return gettext.dgettext('thingtalk', "Please tell me the value of the filter on the %s.").format(canonical);
        }
    }
    get() {
        return this._filter.value;
    }
    set(value) {
        this._filter.value = value;
    }
}

class ArrayIndexSlot extends AbstractSlot {
    constructor(prim, scope, type, array, parent, index) {
        super(prim, scope);
        this._type = type;
        this._array = array;
        if (typeof parent === 'string') {
            this._baseTag = parent;
            this._parent = null;
        } else {
            this._baseTag = parent.tag;
            this._parent = parent;
        }
        this._index = index;
    }

    toString() {
        return `ArrayIndexSlot([${this._index}] : ${this.type})`;
    }

    get _argcanonical() {
        return this._parent._argcanonical;
    }

    get type() {
        return this._type;
    }
    get tag() {
        return `${this._baseTag}[${this._index}]`;
    }
    getPrompt(locale) {
        const gettext = I18n.get(locale);
        const _ = gettext.dgettext.bind(gettext, 'thingtalk');

        switch (this._baseTag) {
        case 'table.index':
            if (this._array.length === 1)
                return _("Which result do you want?");

            switch (this._index) {
            case 0:
                return _("What is the index of the first result you would like?");
            case 1:
                return _("What is the index of the second result you would like?");
            case 2:
                return _("What is the index of the third result you would like?");
            default:
                return _("What is the index of the %dth result you would like?").format(this._index+1);
            }

        case 'attimer.time':
            if (this._array.length === 1)
                return _("When do you want your command to run?");

            switch (this._index) {
            case 0:
                return _("What is the first time you would like your command to run?");
            case 1:
                return _("What is the second time you would like your command to run?");
            case 2:
                return _("What is the third time you would like your command to run?");
            default:
                return _("What is the %dth time you would like your command to run?").format(this._index+1);
            }

        case 'filter.in_array.$source':
            if (this._array.length === 1)
                return _("Who is allowed to ask you for this command?");

            switch (this._index) {
            case 0:
                return _("Who is the first friend who is allowed to ask you for this command?");
            case 1:
                return _("Who is the second friend who is allowed to ask you for this command?");
            case 2:
                return _("Who is the third friend who is allowed to ask you for this command?");
            default:
                return _("Who is the %dth friend who is allowed to ask you for this command?").format(this._index+1);
            }

        default: {
            assert(this._parent);
            // array is input parameter or filter
            if (this._array.length === 1)
                return this._parent.getPrompt(locale);

            const canonical = this._argcanonical;
            switch (this._index) {
            case 0:
                return _("What would you like the first %s to be?").format(canonical);
            case 1:
                return _("What would you like the second %s to be?").format(canonical);
            case 2:
                return _("What would you like the third %s to be?").format(canonical);
            default:
                return _("What would you like the %dth %s to be?").format(this._index+1, canonical);
            }
        }
        }
    }
    get() {
        return this._array[this._index];
    }
    set(value) {
        this._array[this._index] = value;
    }
}

class FieldSlot extends AbstractSlot {
    constructor(prim, scope, type, container, baseTag, field) {
        super(prim, scope);
        this._type = type;
        this._container = container;
        this._tag = baseTag + '.' + field;
        this._field = field;
    }

    toString() {
        return `FieldSlot(${this._field} : ${this.type})`;
    }

    get type() {
        return this._type;
    }
    get tag() {
        return this._tag;
    }

    getPrompt(locale) {
        const gettext = I18n.get(locale);
        const _ = gettext.dgettext.bind(gettext, 'thingtalk');

        switch (this._tag) {
        case 'program.principal':
            return _("Who should run this command?");
        case 'timer.base':
            return _("When would you like your command to start?");
        case 'timer.interval':
            return _("How often should your command run?");
        case 'timer.frequency':
            return _("How many times should your command run during that time interval?");
        case 'attimer.expiration_date':
            return _("When should your command stop?");
        case 'history.base':
        case 'slice.base':
            return _("What is the first result you would like?");
        case 'history.delta':
        case 'slice.limit':
            return _("How many results would you like?");
        case 'result_ref.index':
            return _("Which result do you want?");

        default:
            // should never be hit, because all cases are covered, but who knows...
            return _("What %s would you like?").format(clean(this._field));
        }
    }
    get() {
        return this._container[this._field];
    }
    set(value) {
        this._container[this._field] = value;
    }
}

function makeScope(invocation) {
    // make out parameters available in the "scope", which puts
    // them as possible options for a later slot fill
    const schema = invocation.schema;
    if (!schema)
        return null;
    const scope = {};
    for (let argname in schema.out) {
        let argcanonical = schema.getArgCanonical(argname);

        let kind;
        if (invocation.isVarRef)
            kind = null;
        else if (invocation.isResultRef)
            kind = invocation.kind;
        else
            kind = invocation.selector.kind;
        scope[argname] = {
            value: Value.VarRef(argname),
            type: schema.out[argname],
            argcanonical: argcanonical,

            _prim: invocation,
            kind: kind,
            kind_canonical: schema.class ? (schema.class.metadata.canonical || null) : null,
        };
    }
    scope['$event'] = {
        value: Value.Event(null),
        type: Type.String,
    };
    return scope;
}

function* recursiveYieldArraySlots(slot) {
    yield slot;
    const value = slot.get();
    if (!value.isArray)
        return;

    const type = slot.type;
    assert(type.isArray);
    for (let i = 0; i < value.value.length; i++)
        yield* recursiveYieldArraySlots(new ArrayIndexSlot(slot.primitive, slot.scope, type.elem, value.value, slot, i));
}

module.exports = {
    recursiveYieldArraySlots,
    makeScope,
    InputParamSlot,
    DeviceAttributeSlot,
    FilterSlot,
    ArrayIndexSlot,
    FieldSlot,
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2015-2016 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
8	//
9	// See COPYING for details
10	"use strict";
11
12	const assert = require('assert');	2✔
13	const Type = require('../type');	2✔
14	const I18n = require('../i18n');	2✔
15	const { clean } = require('../utils');	2✔
16
17	const { Value } = require('./values');	2✔
18
19	/**
20	* The abstract representation of a slot.
21	*
22	* A slot is a placeholder for a value that can be replaced or changed by
23	* API user. This API is used to iterate all values (parameters and filters)
24	* in a program.
25	*
26	* @alias Ast~AbstractSlot
27	*/
28	class AbstractSlot {
29	/**
30	* Construct a new abstract slot.
31	*
32	* @param {module.Ast:Invocation\|null} prim - the primitive associated with this slot, if any
33	* @param {Object.<string, Ast.ScopeEntry>} scope - available names for parameter passing
34	* @protected
35	*/
36	constructor(prim, scope) {
37	this._prim = prim;	1,128✔
38
39
40	this._scope = scope;	1,128✔
41	this._options = undefined;	1,128✔
42	}
43
44	get primitive() {
45	return this._prim;	22✔
46	}
47	get scope() {
48	return this._scope;	22✔
49	}
50
51	// the available options to parameter pass from
52	// this is computed lazily because it needs this.type, which
53	// is not available in the constructor
54	get options() {
55	if (this._options)	88!
56	return this._options;	×
57
58	let options = [];	88✔
59	const slotType = this.type;	88✔
60	for (var vname in this._scope) {	88✔
61	let option = this._scope[vname];	158✔
62	if (Type.isAssignable(option.type, slotType))	158✔
63	options.push(option);	42✔
64	}
65	return this._options = options;	88✔
66	}
67
68	/* istanbul ignore next */
69	get type() {
70	throw new Error('Abstract method');
71	}
72	/* istanbul ignore next */
73	getPrompt(locale) {
74	throw new Error('Abstract method');
75	}
76	/* istanbul ignore next */
77	get() {
78	throw new Error('Abstract method');
79	}
80	/* istanbul ignore next */
81	set(value) {
82	throw new Error('Abstract method');
83	}
84
85	isUndefined() {
86	return this.get().isUndefined;	×
87	}
88	isConcrete() {
89	return this.get().isConcrete();	×
90	}
91	isCompilable() {
92	const value = this.get();	586✔
93	if (value.isUndefined)	586!
94	return false;	×
95	if (!value.isConcrete())	586!
96	return false;	×
97
98	const valueType = value.getType();	586✔
99	const slotType = this.type;	586✔
100	if (valueType.isEntity && slotType.isEntity && valueType.type === 'tt:username' && slotType.type !== 'tt:username')	586!
101	return false;	×
102
103	return true;	586✔
104	}
105	}
106
107	class InputParamSlot extends AbstractSlot {
108	constructor(prim, scope, arg, slot) {
109	super(prim, scope);	590✔
110	this._arg = arg;	590✔
111	this._slot = slot;	590✔
112	}
113
114	toString() {
115	return `InputParamSlot(${this._slot.name} : ${this.type})`;	58✔
116	}
117
118	get _argcanonical() {
119	return this._arg ? this._arg.canonical : clean(this._slot.name);	2!
120	}
121
122	get type() {
123	if (this._arg)	490✔
124	return this._arg.type;	436✔
125	else
126	return Type.Any;	54✔
127	}
128	get tag() {
129	return `in_param.${this._slot.name}`;	72✔
130	}
131	getPrompt(locale) {
132	const gettext = I18n.get(locale);	58✔
133	if (this._arg && this._arg.metadata.prompt)	58✔
134	return this._arg.metadata.prompt;	56✔
135
136	const canonical = this._argcanonical;	2✔
137	return gettext.dgettext('thingtalk', "Please tell me the %s.").format(canonical);	2✔
138	}
139	get() {
140	return this._slot.value;	984✔
141	}
142	set(value) {
143	this._slot.value = value;	×
144	}
145	}
146
147	class DeviceAttributeSlot extends AbstractSlot {
148	constructor(prim, attr) {
149	super(prim, {});	16✔
150	this._slot = attr;	16✔
151	assert(this._slot.name === 'name');	16✔
152	}
153
154	toString() {
155	return `DeviceAttributeSlot(${this._slot.name} : ${this.type})`;	2✔
156	}
157
158	get type() {
159	return Type.String;	10✔
160	}
161	get tag() {
162	return `attribute.${this._slot.name}`;	2✔
163	}
164	getPrompt(locale) {
165	// this method should never be used, because $? does not typecheck in a device
166	// attribute, but we include for completeness, and just in case
167	const gettext = I18n.get(locale);	2✔
168	return gettext.dgettext('thingtalk', "Please tell me the name of the device you would like to use.");	2✔
169	}
170	get() {
171	return this._slot.value;	8✔
172	}
173	set(value) {
NEW 174	this._slot.value = value;	×
175	}
176	}
177
178	class FilterSlot extends AbstractSlot {
179	constructor(prim, scope, arg, filter) {
180	super(prim && prim.isPermissionRule ? null : prim, scope);	244✔
181
182	this._isSourceFilter = prim && prim.isPermissionRule;	244✔
183	this._arg = arg;	244✔
184	this._filter = filter;	244✔
185	}
186
187	toString() {
188	return `FilterSlot(${this._filter.name} ${this._filter.operator} : ${this.type})`;	22✔
189	}
190
191	get _argcanonical() {
192	return this._arg ? this._arg.canonical : clean(this._filter.name);	14!
193	}
194
195	// overidde the default option handling to filter out non-sensical filters such as "x == x"
196	get options() {
197	if (this._options)	22!
198	return this._options;	×
199	let options = [];	22✔
200
201	const slotType = this.type;	22✔
202	for (var vname in this._scope) {	22✔
203	let option = this._scope[vname];	74✔
204	if (Type.isAssignable(option.type, slotType)) {	74✔
205	if (option.value.isVarRef && option.value.name === this._filter.name &&	40✔
206	option._prim === this._prim)
207	continue;	14✔
208	if (option.value.isEvent)	26✔
209	continue;	12✔
210	options.push(option);	14✔
211	}
212	}
213	return this._options = options;	22✔
214	}
215
216	get type() {
217	if (this._isSourceFilter) {	182✔
218	switch (this._filter.operator) {	20✔
219	case 'in_array':
220	return new Type.Array(Type.Entity('tt:contact'));	14✔
221	default:
222	return Type.Entity('tt:contact');	6✔
223	}
224	} else if (this._arg) {	162!
225	switch (this._filter.operator) {	162!
226	case 'contains':
227	return this._arg.type.elem;	×
228	case 'in_array':
229	return new Type.Array(this._arg.type);	2✔
230	default:
231	return this._arg.type;	160✔
232	}
233	} else {
234	return Type.Any;	×
235	}
236	}
237	get tag() {
238	return `filter.${this._filter.operator}.${this._isSourceFilter ? '$' : ''}${this._filter.name}`;	30✔
239	}
240	getPrompt(locale) {
241	const gettext = I18n.get(locale);	22✔
242	if (['==', 'contains', 'in_array', '=~'].indexOf(this._filter.operator) >= 0 &&	22✔
243	this._arg && this._arg.metadata.prompt)
244	return this._arg.metadata.prompt;	2✔
245
246	if (this._isSourceFilter)	20✔
247	return gettext.dgettext('thingtalk', "Who is allowed to ask you for this command?");	6✔
248
249	const canonical = this._argcanonical;	14✔
250	switch (this._filter.operator) {	14!
251	case '>=':
252	return gettext.dgettext('thingtalk', "What should the %s be greater than?").format(canonical);	×
253	case '<=':
254	return gettext.dgettext('thingtalk', "What should the %s be less than?").format(canonical);	×
255	case 'starts_with':
256	return gettext.dgettext('thingtalk', "How should the %s start with?").format(canonical);	×
257	case 'ends_with':
258	return gettext.dgettext('thingtalk', "How should the %s end with?").format(canonical);	×
259	case '=~':
260	return gettext.dgettext('thingtalk', "What should the %s contain?").format(canonical);	14✔
261	case '==':
262	return gettext.dgettext('thingtalk', "What should the %s be equal to?").format(canonical);	×
263	default:
264	// ugly default but guaranteed to work...
265	return gettext.dgettext('thingtalk', "Please tell me the value of the filter on the %s.").format(canonical);	×
266	}
267	}
268	get() {
269	return this._filter.value;	386✔
270	}
271	set(value) {
272	this._filter.value = value;	×
273	}
274	}
275
276	class ArrayIndexSlot extends AbstractSlot {
277	constructor(prim, scope, type, array, parent, index) {
278	super(prim, scope);	138✔
279	this._type = type;	138✔
280	this._array = array;	138✔
281	if (typeof parent === 'string') {	138✔
282	this._baseTag = parent;	116✔
283	this._parent = null;	116✔
284	} else {
285	this._baseTag = parent.tag;	22✔
286	this._parent = parent;	22✔
287	}
288	this._index = index;	138✔
289	}
290
291	toString() {
292	return `ArrayIndexSlot([${this._index}] : ${this.type})`;	18✔
293	}
294
295	get _argcanonical() {
296	return this._parent._argcanonical;	×
297	}
298
299	get type() {
300	return this._type;	116✔
301	}
302	get tag() {
303	return `${this._baseTag}[${this._index}]`;	18✔
304	}
305	getPrompt(locale) {
306	const gettext = I18n.get(locale);	18✔
307	const _ = gettext.dgettext.bind(gettext, 'thingtalk');	18✔
308
309	switch (this._baseTag) {	18!
310	case 'table.index':
311	if (this._array.length === 1)	4!
312	return _("Which result do you want?");	×
313
314	switch (this._index) {	4!
315	case 0:
316	return _("What is the index of the first result you would like?");	2✔
317	case 1:
318	return _("What is the index of the second result you would like?");	2✔
319	case 2:
320	return _("What is the index of the third result you would like?");	×
321	default:
322	return _("What is the index of the %dth result you would like?").format(this._index+1);	×
323	}
324
325	case 'attimer.time':
326	if (this._array.length === 1)	10✔
327	return _("When do you want your command to run?");	2✔
328
329	switch (this._index) {	8!
330	case 0:
331	return _("What is the first time you would like your command to run?");	4✔
332	case 1:
333	return _("What is the second time you would like your command to run?");	4✔
334	case 2:
335	return _("What is the third time you would like your command to run?");	×
336	default:
337	return _("What is the %dth time you would like your command to run?").format(this._index+1);	×
338	}
339
340	case 'filter.in_array.$source':
341	if (this._array.length === 1)	4!
342	return _("Who is allowed to ask you for this command?");	×
343
344	switch (this._index) {	4!
345	case 0:
346	return _("Who is the first friend who is allowed to ask you for this command?");	2✔
347	case 1:
348	return _("Who is the second friend who is allowed to ask you for this command?");	2✔
349	case 2:
350	return _("Who is the third friend who is allowed to ask you for this command?");	×
351	default:
352	return _("Who is the %dth friend who is allowed to ask you for this command?").format(this._index+1);	×
353	}
354
355	default: {
356	assert(this._parent);	×
357	// array is input parameter or filter
358	if (this._array.length === 1)	×
359	return this._parent.getPrompt(locale);	×
360
361	const canonical = this._argcanonical;	×
362	switch (this._index) {	×
363	case 0:
364	return _("What would you like the first %s to be?").format(canonical);	×
365	case 1:
366	return _("What would you like the second %s to be?").format(canonical);	×
367	case 2:
368	return _("What would you like the third %s to be?").format(canonical);	×
369	default:
370	return _("What would you like the %dth %s to be?").format(this._index+1, canonical);	×
371	}
372	}
373	}
374	}
375	get() {
376	return this._array[this._index];	226✔
377	}
378	set(value) {
379	this._array[this._index] = value;	×
380	}
381	}
382
383	class FieldSlot extends AbstractSlot {
384	constructor(prim, scope, type, container, baseTag, field) {
385	super(prim, scope);	140✔
386	this._type = type;	140✔
387	this._container = container;	140✔
388	this._tag = baseTag + '.' + field;	140✔
389	this._field = field;	140✔
390	}
391
392	toString() {
393	return `FieldSlot(${this._field} : ${this.type})`;	10✔
394	}
395
396	get type() {
397	return this._type;	130✔
398	}
399	get tag() {
400	return this._tag;	10✔
401	}
402
403	getPrompt(locale) {
404	const gettext = I18n.get(locale);	10✔
405	const _ = gettext.dgettext.bind(gettext, 'thingtalk');	10✔
406
407	switch (this._tag) {	10!
408	case 'program.principal':
409	return _("Who should run this command?");	2✔
410	case 'timer.base':
411	return _("When would you like your command to start?");	×
412	case 'timer.interval':
413	return _("How often should your command run?");	×
414	case 'timer.frequency':
415	return _("How many times should your command run during that time interval?");	×
416	case 'attimer.expiration_date':
417	return _("When should your command stop?");	2✔
418	case 'history.base':
419	case 'slice.base':
420	return _("What is the first result you would like?");	2✔
421	case 'history.delta':
422	case 'slice.limit':
423	return _("How many results would you like?");	2✔
424	case 'result_ref.index':
425	return _("Which result do you want?");	2✔
426
427	default:
428	// should never be hit, because all cases are covered, but who knows...
429	return _("What %s would you like?").format(clean(this._field));	×
430	}
431	}
432	get() {
433	return this._container[this._field];	250✔
434	}
435	set(value) {
436	this._container[this._field] = value;	×
437	}
438	}
439
440	function makeScope(invocation) {
441	// make out parameters available in the "scope", which puts
442	// them as possible options for a later slot fill
443	const schema = invocation.schema;	2,552✔
444	if (!schema)	2,552✔
445	return null;	18✔
446	const scope = {};	2,534✔
447	for (let argname in schema.out) {	2,534✔
448	let argcanonical = schema.getArgCanonical(argname);	7,356✔
449
450	let kind;
451	if (invocation.isVarRef)	7,356✔
452	kind = null;	1,246✔
453	else if (invocation.isResultRef)	6,110✔
454	kind = invocation.kind;	120✔
455	else
456	kind = invocation.selector.kind;	5,990✔
457	scope[argname] = {	7,356✔
458	value: Value.VarRef(argname),
459	type: schema.out[argname],
460	argcanonical: argcanonical,
461
462	_prim: invocation,
463	kind: kind,
464	kind_canonical: schema.class ? (schema.class.metadata.canonical \|\| null) : null,	14,324✔
465	};
466	}
467	scope['$event'] = {	2,534✔
468	value: Value.Event(null),
469	type: Type.String,
470	};
471	return scope;	2,534✔
472	}
473
474	function* recursiveYieldArraySlots(slot) {
475	yield slot;	1,112✔
476	const value = slot.get();	1,112✔
477	if (!value.isArray)	1,112✔
478	return;	1,100✔
479
480	const type = slot.type;	12✔
481	assert(type.isArray);	12✔
482	for (let i = 0; i < value.value.length; i++)	12✔
483	yield* recursiveYieldArraySlots(new ArrayIndexSlot(slot.primitive, slot.scope, type.elem, value.value, slot, i));	22✔
484	}
485
486	module.exports = {	2✔
487	recursiveYieldArraySlots,
488	makeScope,
489	InputParamSlot,
490	DeviceAttributeSlot,
491	FilterSlot,
492	ArrayIndexSlot,
493	FieldSlot,
494	};

stanford-oval / thingtalk / 715

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