1568

pending completion

Build # 1568

Build Type

Pull #397

travis-ci-com

Committed by

web-flow

Commit Message

Merge 06dd6b0da into 9b347280c

Pull Request Pull Request #397: Misc fixes

Run Details

4637 of 6474 branches covered (71.62%)

Branch coverage included in aggregate %.

49 of 55 new or added lines in 4 files covered. (89.09%)

1 existing line in 1 file now uncovered.

10521 of 12998 relevant lines covered (80.94%)

50385.98 hits per line

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

57.37

/lib/runtime/values.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2018-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 { Temporal, toTemporalInstant, } from '@js-temporal/polyfill';

import { stringEscape } from '../utils/escaping';

/**
 * Runtime representation of an entity value.
 *
 */
export class Entity {
    /**
     * The entity identifier value.
     */
    value : string;
    /**
     * The entity display name.
     */
    display : string|null;

    /**
     * Match this entity against a query string.
     *
     * This optional property can be set to override the behavior of the `=~` operator
     * for this entity.
     *
     * Note that the evaluation order of ThingTalk is unspecified, so this method must
     * have no side effects.
     *
     * @param against the query to check against
     * @returns true if the query matches, false otherwise
     */
    softmatch?(against : string) : boolean;

    /**
     * Construct a new entity value.
     *
     * @param value - the entity identifier value
     * @param display - optional human-readable display name for the entity
     */
    constructor(id : string, display ?: string|null, options : { softmatch ?: (against : string) => boolean } = {}) {
        this.value = id;
        this.display = display||null;

        // set the property only if provided
        // this allows subclasses to implement the method normally
        if (options.softmatch)
            this.softmatch = options.softmatch;
    }

    toString() : string {
        return this.value;
    }

    /**
     * Compile the entity value to JS code.
     *
     * @return {string} JS code that evaluates to this entity value
     */
    toJSSource() : string {
        return `new __builtin.Entity(${stringEscape(this.value)}, ${stringEscape(this.display)})`;
    }

    /**
     * Check if this JS value looks like an entity.
     *
     * @param {any} obj - the JS value to check
     * @return {boolean} `true` if the value is a string or an instance of this class
     */
    static isEntity(obj : unknown) : obj is (Entity|string) {
        return obj instanceof Entity || typeof obj === 'string';
    }
}

/**
 * Runtime representation of a string-like object.
 *
 * Objects of this class can be used to override the behavior of
 * string operators at runtime.
 */
export class StringLike {
    /**
     * The underlying string value.
     */
    private value : string;

    /**
     * Match this string against a query string.
     *
     * This optional property can be set to override the behavior of the `=~` operator.
     *
     * Note that the evaluation order of ThingTalk is unspecified, so this method must
     * have no side effects.
     *
     * @param against the query to check against
     * @returns true if the query matches, false otherwise
     */
    softmatch?(against : string) : boolean;

    /**
     * Construct a new string-like object.
     *
     * @param value - the string value
     */
    constructor(id : string, options : { softmatch ?: (against : string) => boolean } = {}) {
        this.value = id;

        // set the property only if provided
        // this allows subclasses to implement the method normally
        if (options.softmatch)
            this.softmatch = options.softmatch;
    }

    toString() {
        return this.value;
    }

    valueOf() {
        return this.value;
    }

    /**
     * Compile this to JS code.
     *
     * @return {string} JS code that evaluates to this value
     * @package
     */
    toJSSource() : string {
        return stringEscape(this.value);
    }
}

export interface LocationLike {
    x : number;
    y : number;
    display ?: string|null;
}

/**
 * Runtime representation of a location value.
 *
 */
export class Location implements LocationLike {
    /**
     * Longitude value.
     * @deprecated Use {@link lon}
     */
    x : number;
    /**
     * Latitude value.
     * @deprecated Use {@link lat}
     */
    y : number;
    /**
     * Display name for this location.
     */
    display : string|null;

    /**
     * Construct a new location value.
     *
     * @param {number} lat - latitude in degrees (between -90 and 90)
     * @param {number} lon - longitude in degrees (between -180 and 180)
     * @param {string|null} [display] - human-readable display name for this location
     */
    constructor(lat : number, lon : number, display ?: string|null) {
        if (typeof lat !== 'number' || typeof lon !== 'number')
            throw new Error(`Invalid location (${lat}, ${lon})`);

        this.x = lon;
        this.y = lat;
        this.display = display||null;
    }

    /**
     * Latitude value.
     */
    get lat() : number {
        return this.y;
    }
    /**
     * Longitude value.
     */
    get lon() : number {
        return this.x;
    }

    toString() : string {
        if (this.display !== null)
            return this.display;
        else
            return '[Latitude: ' + Number(this.y).toFixed(5) + ' deg, Longitude: ' + Number(this.x).toFixed(5) + ' deg]';
    }

    /**
     * Compile the location value to JS code.
     *
     * @return {string} JS code that evaluates to this location value
     * @package
     */
    toJSSource() : string {
        return `new __builtin.Location(${this.y}, ${this.x}, ${stringEscape(this.display)})`;
    }

    /**
     * Check if this JS value looks like an location.
     *
     * For compatibility reasons, the runtime representation of a location is not required
     * to be an instance of the {@link Builtin.Location} class, and can be any object
     * with `x` and `y` own properties.
     *
     * @param {any} obj - the JS value to check
     * @return {boolean} `true` if the value looks like a location
     * @package
     */
    static isLocation(obj : unknown) : obj is LocationLike {
        return (obj instanceof Location || (typeof obj === 'object' && obj !== null &&
            Object.prototype.hasOwnProperty.call(obj, 'x') && Object.prototype.hasOwnProperty.call(obj, 'y')));
    }
}

/**
 * Runtime representation of a time value.
 *
 */
export class Time {
    /**
     * Hour value.
     */
    hour : number;
    /**
     * Minute value.
     */
    minute : number;
    /**
     * Second value.
     */
    second : number;

    /**
     * Construct a new time value.
     *
     * @param {number} hour - hour value (between 0 and 11)
     * @param {number} minute - minute value (between 0 and 59)
     * @param {number} [second] - second value (between 0 and 59)
     */
    constructor(hour : number, minute : number, second = 0) {
        if (!(hour >= 0) || !(minute >= 0) || !(second >= 0))
            throw new Error(`Invalid time ${hour}:${minute}:${second}`);
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }

    static fromSeconds(seconds : number) : Time {
        const hour = Math.floor(seconds / 3600);
        seconds -= hour * 3600;
        const minute = Math.floor(seconds / 60);
        seconds -= minute * 60;
        return new Time(hour, minute, seconds);
    }

    static fromTemporal(time : Temporal.PlainTime) {
        return new Time(time.hour, time.minute, time.second);
    }

    // for comparisons
    /**
     * Convert this time value to the number of seconds since midnight.
     *
     * This can be used to compare time values using `<` and `>`
     * @return {number} the number of seconds since midnight
     */
    valueOf() : number {
        return this.hour * 3600 + this.minute * 60 + this.second;
    }

    toString() : string {
        if (this.second === 0)
            return `${this.hour}:${this.minute < 10 ? '0' : ''}${this.minute}`;
        else
            return `${this.hour}:${this.minute < 10 ? '0' : ''}${this.minute}:${this.second < 10 ? '0' : ''}${this.second}`;
    }

    toJSON() : string {
        return this.toString();
    }

    /**
     * Compile the time value to JS code.
     *
     * @return {string} JS code that evaluates to this time value
     * @package
     */
    toJSSource() : string {
        return `new __builtin.Time(${this.hour}, ${this.minute}, ${this.second})`;
    }
}

/**
 * Runtime representation of a currency value.
 *
 */
export class Currency {
    value : number;
    code : string;

    constructor(value : number, code : string) {
        this.value = value;
        this.code = code;
    }

    valueOf() : number {
        return this.value;
    }

    toString() : string {
        return `${this.value} ${this.code.toUpperCase()}`;
    }

    toLocaleString(locale : string, options : Intl.NumberFormatOptions = {}) : string {
        options.style = 'currency';
        options.currency = this.code.toUpperCase();
        return this.value.toLocaleString(locale, options);
    }

    toJSSource() : string {
        return `new __builtin.Currency(${this.value}, "${this.code}")`;
    }
}

export interface RecurrentTimeRuleLike {
    beginTime : Time;
    endTime : Time;
    interval : number;
    frequency : number;
    dayOfWeek : number|null;
    beginDate : Date|null;
    endDate : Date|null;
    subtract : boolean;
}

/**
 * Runtime representation of a recurrent time rule (a single item in a recurrent time specification).
 *
 */
export class RecurrentTimeRule implements RecurrentTimeRuleLike {
    beginTime : Time;
    endTime : Time;
    interval : number;
    frequency : number;
    dayOfWeek : number|null;
    beginDate : Date|null;
    endDate : Date|null;
    subtract : boolean;

    constructor({
        beginTime,
        endTime,
        interval = 86400000,
        frequency = 1,
        dayOfWeek = null,
        beginDate = null,
        endDate = null,
        subtract = false
    } : RecurrentTimeRuleLike) {
        assert(beginTime instanceof Time);
        assert(endTime instanceof Time);
        assert(typeof interval === 'number');
        assert(typeof frequency === 'number');
        assert(dayOfWeek === null || (typeof dayOfWeek === 'number' && dayOfWeek >= 0 && dayOfWeek <= 6));
        assert(beginDate === null || beginDate instanceof Date);
        assert(endDate === null || endDate instanceof Date);
        assert(typeof subtract === 'boolean');
        this.beginTime = beginTime;
        this.endTime = endTime;
        this.interval = interval;
        this.frequency = frequency;
        this.dayOfWeek = dayOfWeek;
        this.beginDate = beginDate;
        this.endDate = endDate;
        this.subtract = subtract;
    }

    toString() : string {
        return `RecurrentTimeRule(${this.beginTime} -- ${this.endTime}; ${this.frequency} every ${this.interval} ms; from ${this.beginDate} to ${this.endDate})`;
    }

    toJSSource() : string {
        return `new __builtin.RecurrentTimeRule({ `
        + `beginTime: ${this.beginTime.toJSSource()}, `
        + `endTime: ${this.endTime.toJSSource()}, `
        + `interval: ${this.interval}, `
        + `frequency: ${this.frequency}, `
        + `dayOfWeek: ${this.dayOfWeek}, `
        + 'beginDate: ' + (this.beginDate ? `new Date(${this.beginDate.getTime()})` : 'null') + ', '
        + 'endDate: ' + (this.endDate ? `new Date(${this.endDate.getTime()})` : 'null') + ', '
        + `subtract: ${this.subtract}, `
        + '})';
    }

    contains(dateOrTime : Date|Temporal.ZonedDateTime|Temporal.PlainTime|Time) : boolean {
        let time;
        let instant;
        let dayOfWeek;

        if (dateOrTime instanceof Date) {
            // this is not correct wrt timezone but if all we have is a date that's all we can do
            time = new Time(dateOrTime.getHours(), dateOrTime.getMinutes(), dateOrTime.getSeconds());
            dayOfWeek = dateOrTime.getDay();
            instant = toTemporalInstant.call(dateOrTime);
        } else if (dateOrTime instanceof Temporal.ZonedDateTime) {
            time = Time.fromTemporal(dateOrTime.toPlainTime());
            dayOfWeek = dateOrTime.dayOfWeek;
            instant = dateOrTime.toInstant();
        } else if (dateOrTime instanceof Temporal.PlainTime) {
            time = Time.fromTemporal(dateOrTime);
            dayOfWeek = undefined;
            instant = undefined;
        } else {
            time = dateOrTime;
            dayOfWeek = undefined;
            instant = undefined;
        }

        if (!(this.beginTime <= time && this.endTime >= time))
            return false;

        if (instant) {
            if (this.beginDate && this.beginDate.getTime() > instant.epochMilliseconds)
                return false;
            if (this.endDate && this.endDate.getTime() < instant.epochMilliseconds)
                return false;
        }

        if (dayOfWeek) {
            if (this.dayOfWeek !== null && this.dayOfWeek !== dayOfWeek)
                return false;
        }

        // TODO frequency and interval
        return true;
    }
}

export class Aggregation {
    constructor(public type : string,
                public field : string,
                public cols : string,
                public count : number) {
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2018-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	import { Temporal, toTemporalInstant, } from '@js-temporal/polyfill';	2✔
23
24	import { stringEscape } from '../utils/escaping';	2✔
25
26	/**
27	* Runtime representation of an entity value.
28	*
29	*/
30	export class Entity {	2✔
31	/**
32	* The entity identifier value.
33	*/
34	value : string;
35	/**
36	* The entity display name.
37	*/
38	display : string\|null;
39
40	/**
41	* Match this entity against a query string.
42	*
43	* This optional property can be set to override the behavior of the `=~` operator
44	* for this entity.
45	*
46	* Note that the evaluation order of ThingTalk is unspecified, so this method must
47	* have no side effects.
48	*
49	* @param against the query to check against
50	* @returns true if the query matches, false otherwise
51	*/
52	softmatch?(against : string) : boolean;
53
54	/**
55	* Construct a new entity value.
56	*
57	* @param value - the entity identifier value
58	* @param display - optional human-readable display name for the entity
59	*/
60	constructor(id : string, display ?: string\|null, options : { softmatch ?: (against : string) => boolean } = {}) {	276✔
61	this.value = id;	278✔
62	this.display = display\|\|null;	278✔
63
64	// set the property only if provided
65	// this allows subclasses to implement the method normally
66	if (options.softmatch)	278✔
67	this.softmatch = options.softmatch;	2✔
68	}
69
70	toString() : string {
71	return this.value;	158✔
72	}
73
74	/**
75	* Compile the entity value to JS code.
76	*
77	* @return {string} JS code that evaluates to this entity value
78	*/
79	toJSSource() : string {
80	return `new __builtin.Entity(${stringEscape(this.value)}, ${stringEscape(this.display)})`;	76✔
81	}
82
83	/**
84	* Check if this JS value looks like an entity.
85	*
86	* @param {any} obj - the JS value to check
87	* @return {boolean} `true` if the value is a string or an instance of this class
88	*/
89	static isEntity(obj : unknown) : obj is (Entity\|string) {
90	return obj instanceof Entity \|\| typeof obj === 'string';	126✔
91	}
92	}
93
94	/**
95	* Runtime representation of a string-like object.
96	*
97	* Objects of this class can be used to override the behavior of
98	* string operators at runtime.
99	*/
100	export class StringLike {	2✔
101	/**
102	* The underlying string value.
103	*/
104	private value : string;
105
106	/**
107	* Match this string against a query string.
108	*
109	* This optional property can be set to override the behavior of the `=~` operator.
110	*
111	* Note that the evaluation order of ThingTalk is unspecified, so this method must
112	* have no side effects.
113	*
114	* @param against the query to check against
115	* @returns true if the query matches, false otherwise
116	*/
117	softmatch?(against : string) : boolean;
118
119	/**
120	* Construct a new string-like object.
121	*
122	* @param value - the string value
123	*/
124	constructor(id : string, options : { softmatch ?: (against : string) => boolean } = {}) {	12✔
125	this.value = id;	14✔
126
127	// set the property only if provided
128	// this allows subclasses to implement the method normally
129	if (options.softmatch)	14✔
130	this.softmatch = options.softmatch;	2✔
131	}
132
133	toString() {
134	return this.value;	6✔
135	}
136
137	valueOf() {
138	return this.value;	10✔
139	}
140
141	/**
142	* Compile this to JS code.
143	*
144	* @return {string} JS code that evaluates to this value
145	* @package
146	*/
147	toJSSource() : string {
NEW 148	return stringEscape(this.value);	×
149	}
150	}
151
152	export interface LocationLike {
153	x : number;
154	y : number;
155	display ?: string\|null;
156	}
157
158	/**
159	* Runtime representation of a location value.
160	*
161	*/
162	export class Location implements LocationLike {	2✔
163	/**
164	* Longitude value.
165	* @deprecated Use {@link lon}
166	*/
167	x : number;
168	/**
169	* Latitude value.
170	* @deprecated Use {@link lat}
171	*/
172	y : number;
173	/**
174	* Display name for this location.
175	*/
176	display : string\|null;
177
178	/**
179	* Construct a new location value.
180	*
181	* @param {number} lat - latitude in degrees (between -90 and 90)
182	* @param {number} lon - longitude in degrees (between -180 and 180)
183	* @param {string\|null} [display] - human-readable display name for this location
184	*/
185	constructor(lat : number, lon : number, display ?: string\|null) {
186	if (typeof lat !== 'number' \|\| typeof lon !== 'number')	58!
187	throw new Error(`Invalid location (${lat}, ${lon})`);	×
188
189	this.x = lon;	58✔
190	this.y = lat;	58✔
191	this.display = display\|\|null;	58✔
192	}
193
194	/**
195	* Latitude value.
196	*/
197	get lat() : number {
198	return this.y;	×
199	}
200	/**
201	* Longitude value.
202	*/
203	get lon() : number {
204	return this.x;	×
205	}
206
207	toString() : string {
208	if (this.display !== null)	14✔
209	return this.display;	6✔
210	else
211	return '[Latitude: ' + Number(this.y).toFixed(5) + ' deg, Longitude: ' + Number(this.x).toFixed(5) + ' deg]';	8✔
212	}
213
214	/**
215	* Compile the location value to JS code.
216	*
217	* @return {string} JS code that evaluates to this location value
218	* @package
219	*/
220	toJSSource() : string {
221	return `new __builtin.Location(${this.y}, ${this.x}, ${stringEscape(this.display)})`;	30✔
222	}
223
224	/**
225	* Check if this JS value looks like an location.
226	*
227	* For compatibility reasons, the runtime representation of a location is not required
228	* to be an instance of the {@link Builtin.Location} class, and can be any object
229	* with `x` and `y` own properties.
230	*
231	* @param {any} obj - the JS value to check
232	* @return {boolean} `true` if the value looks like a location
233	* @package
234	*/
235	static isLocation(obj : unknown) : obj is LocationLike {
236	return (obj instanceof Location \|\| (typeof obj === 'object' && obj !== null &&	100✔
237	Object.prototype.hasOwnProperty.call(obj, 'x') && Object.prototype.hasOwnProperty.call(obj, 'y')));
238	}
239	}
240
241	/**
242	* Runtime representation of a time value.
243	*
244	*/
245	export class Time {	2✔
246	/**
247	* Hour value.
248	*/
249	hour : number;
250	/**
251	* Minute value.
252	*/
253	minute : number;
254	/**
255	* Second value.
256	*/
257	second : number;
258
259	/**
260	* Construct a new time value.
261	*
262	* @param {number} hour - hour value (between 0 and 11)
263	* @param {number} minute - minute value (between 0 and 59)
264	* @param {number} [second] - second value (between 0 and 59)
265	*/
266	constructor(hour : number, minute : number, second = 0) {	36✔
267	if (!(hour >= 0) \|\| !(minute >= 0) \|\| !(second >= 0))	114✔
268	throw new Error(`Invalid time ${hour}:${minute}:${second}`);	14✔
269	this.hour = hour;	100✔
270	this.minute = minute;	100✔
271	this.second = second;	100✔
272	}
273
274	static fromSeconds(seconds : number) : Time {
275	const hour = Math.floor(seconds / 3600);	×
276	seconds -= hour * 3600;	×
277	const minute = Math.floor(seconds / 60);	×
278	seconds -= minute * 60;	×
279	return new Time(hour, minute, seconds);	×
280	}
281
282	static fromTemporal(time : Temporal.PlainTime) {
283	return new Time(time.hour, time.minute, time.second);	×
284	}
285
286	// for comparisons
287	/**
288	* Convert this time value to the number of seconds since midnight.
289	*
290	* This can be used to compare time values using `<` and `>`
291	* @return {number} the number of seconds since midnight
292	*/
293	valueOf() : number {
294	return this.hour * 3600 + this.minute * 60 + this.second;	46✔
295	}
296
297	toString() : string {
298	if (this.second === 0)	20✔
299	return `${this.hour}:${this.minute < 10 ? '0' : ''}${this.minute}`;	12!
300	else
301	return `${this.hour}:${this.minute < 10 ? '0' : ''}${this.minute}:${this.second < 10 ? '0' : ''}${this.second}`;	8!
302	}
303
304	toJSON() : string {
305	return this.toString();	×
306	}
307
308	/**
309	* Compile the time value to JS code.
310	*
311	* @return {string} JS code that evaluates to this time value
312	* @package
313	*/
314	toJSSource() : string {
315	return `new __builtin.Time(${this.hour}, ${this.minute}, ${this.second})`;	46✔
316	}
317	}
318
319	/**
320	* Runtime representation of a currency value.
321	*
322	*/
323	export class Currency {	2✔
324	value : number;
325	code : string;
326
327	constructor(value : number, code : string) {
328	this.value = value;	72✔
329	this.code = code;	72✔
330	}
331
332	valueOf() : number {
333	return this.value;	24✔
334	}
335
336	toString() : string {
337	return `${this.value} ${this.code.toUpperCase()}`;	28✔
338	}
339
340	toLocaleString(locale : string, options : Intl.NumberFormatOptions = {}) : string {	×
341	options.style = 'currency';	×
342	options.currency = this.code.toUpperCase();	×
343	return this.value.toLocaleString(locale, options);	×
344	}
345
346	toJSSource() : string {
347	return `new __builtin.Currency(${this.value}, "${this.code}")`;	6✔
348	}
349	}
350
351	export interface RecurrentTimeRuleLike {
352	beginTime : Time;
353	endTime : Time;
354	interval : number;
355	frequency : number;
356	dayOfWeek : number\|null;
357	beginDate : Date\|null;
358	endDate : Date\|null;
359	subtract : boolean;
360	}
361
362	/**
363	* Runtime representation of a recurrent time rule (a single item in a recurrent time specification).
364	*
365	*/
366	export class RecurrentTimeRule implements RecurrentTimeRuleLike {	2✔
367	beginTime : Time;
368	endTime : Time;
369	interval : number;
370	frequency : number;
371	dayOfWeek : number\|null;
372	beginDate : Date\|null;
373	endDate : Date\|null;
374	subtract : boolean;
375
376	constructor({
377	beginTime,
378	endTime,
379	interval = 86400000,	4✔
380	frequency = 1,	4✔
381	dayOfWeek = null,	4✔
382	beginDate = null,	2✔
383	endDate = null,	2✔
384	subtract = false	4✔
385	} : RecurrentTimeRuleLike) {
386	assert(beginTime instanceof Time);	12✔
387	assert(endTime instanceof Time);	12✔
388	assert(typeof interval === 'number');	12✔
389	assert(typeof frequency === 'number');	12✔
390	assert(dayOfWeek === null \|\| (typeof dayOfWeek === 'number' && dayOfWeek >= 0 && dayOfWeek <= 6));	12!
391	assert(beginDate === null \|\| beginDate instanceof Date);	12✔
392	assert(endDate === null \|\| endDate instanceof Date);	12✔
393	assert(typeof subtract === 'boolean');	12✔
394	this.beginTime = beginTime;	12✔
395	this.endTime = endTime;	12✔
396	this.interval = interval;	12✔
397	this.frequency = frequency;	12✔
398	this.dayOfWeek = dayOfWeek;	12✔
399	this.beginDate = beginDate;	12✔
400	this.endDate = endDate;	12✔
401	this.subtract = subtract;	12✔
402	}
403
404	toString() : string {
405	return `RecurrentTimeRule(${this.beginTime} -- ${this.endTime}; ${this.frequency} every ${this.interval} ms; from ${this.beginDate} to ${this.endDate})`;	×
406	}
407
408	toJSSource() : string {
409	return `new __builtin.RecurrentTimeRule({ `	4✔
410	+ `beginTime: ${this.beginTime.toJSSource()}, `
411	+ `endTime: ${this.endTime.toJSSource()}, `
412	+ `interval: ${this.interval}, `
413	+ `frequency: ${this.frequency}, `
414	+ `dayOfWeek: ${this.dayOfWeek}, `
415	+ 'beginDate: ' + (this.beginDate ? `new Date(${this.beginDate.getTime()})` : 'null') + ', '	4!
416	+ 'endDate: ' + (this.endDate ? `new Date(${this.endDate.getTime()})` : 'null') + ', '	4!
417	+ `subtract: ${this.subtract}, `
418	+ '})';
419	}
420
421	contains(dateOrTime : Date\|Temporal.ZonedDateTime\|Temporal.PlainTime\|Time) : boolean {
422	let time;
423	let instant;
424	let dayOfWeek;
425
426	if (dateOrTime instanceof Date) {	×
427	// this is not correct wrt timezone but if all we have is a date that's all we can do
428	time = new Time(dateOrTime.getHours(), dateOrTime.getMinutes(), dateOrTime.getSeconds());	×
429	dayOfWeek = dateOrTime.getDay();	×
430	instant = toTemporalInstant.call(dateOrTime);	×
431	} else if (dateOrTime instanceof Temporal.ZonedDateTime) {	×
432	time = Time.fromTemporal(dateOrTime.toPlainTime());	×
433	dayOfWeek = dateOrTime.dayOfWeek;	×
434	instant = dateOrTime.toInstant();	×
435	} else if (dateOrTime instanceof Temporal.PlainTime) {	×
436	time = Time.fromTemporal(dateOrTime);	×
437	dayOfWeek = undefined;	×
438	instant = undefined;	×
439	} else {
440	time = dateOrTime;	×
441	dayOfWeek = undefined;	×
442	instant = undefined;	×
443	}
444
445	if (!(this.beginTime <= time && this.endTime >= time))	×
446	return false;	×
447
448	if (instant) {	×
449	if (this.beginDate && this.beginDate.getTime() > instant.epochMilliseconds)	×
450	return false;	×
451	if (this.endDate && this.endDate.getTime() < instant.epochMilliseconds)	×
452	return false;	×
453	}
454
455	if (dayOfWeek) {	×
456	if (this.dayOfWeek !== null && this.dayOfWeek !== dayOfWeek)	×
457	return false;	×
458	}
459
460	// TODO frequency and interval
461	return true;	×
462	}
463	}
464
465	export class Aggregation {	2✔
466	constructor(public type : string,	×
467	public field : string,	×
468	public cols : string,	×
469	public count : number) {	×
470	}
471	}

stanford-oval / thingtalk / 1568

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