1535

pending completion

Build # 1535

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #387 from stanford-oval/wip/timezone-issues

Make ThingTalk timezone-aware

Run Details

4615 of 6460 branches covered (71.44%)

Branch coverage included in aggregate %.

61 of 107 new or added lines in 13 files covered. (57.01%)

204 existing lines in 3 files now uncovered.

10501 of 12981 relevant lines covered (80.9%)

48308.68 hits per line

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

67.46

/lib/runtime/primitive_ops.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 * as Ast from '../ast';

import type { ExecEnvironment } from './exec_environment';
import {
    LocationLike,
    Location,
    Entity,
    Time,
    Currency,
    RecurrentTimeRule
} from './values';

// Implementations of the ThingTalk operators

function arrayEquals(a : unknown[], b : unknown[]) : boolean {
    if (a.length !== b.length)
        return false;

    for (let i = 0; i < a.length; i++) {
        if (!equality(a[i], b[i]))
            return false;
    }

    return true;
}

function objectEquals<T1, T2>(a : T1, b : T2) : boolean {
    const a_props = Object.getOwnPropertyNames(a) as Array<keyof T1>;
    const b_props = Object.getOwnPropertyNames(b) as Array<keyof T2>;

    if (a_props.length !== b_props.length)
        return false;

    for (let i = 0; i < a_props.length; i ++) {
        if (!equality(a[a_props[i]], b[a_props[i] as unknown as keyof T2]))
            return false;
    }

    return true;
}

export function distance(a : LocationLike, b : LocationLike) : number {
    const R = 6371000; // meters
    const lat1 = a.y;
    const lat2 = b.y;
    const lon1 = a.x;
    const lon2 = a.x;
    function toRadians(deg : number) { return deg * Math.PI / 180.0; }

    // formula courtesy of http://www.movable-type.co.uk/scripts/latlong.html
    const φ1 = toRadians(lat1);
    const φ2 = toRadians(lat2);
    const Δφ = toRadians(lat2-lat1);
    const Δλ = toRadians(lon2-lon1);

    const x = Math.sin(Δφ/2) * Math.sin(Δφ/2) +
            Math.cos(φ1) * Math.cos(φ2) *
            Math.sin(Δλ/2) * Math.sin(Δλ/2);
    const c = 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1-x));

    return R * c;
}

function locationEquals(a : LocationLike, b : LocationLike) : boolean {
    if (a === b)
        return true;
    if (a.x === b.x && a.y === b.y)
        return true;
    //console.log('Comparing locations', [a,b]);
    const d = distance(a, b);
    //console.log('Distance (m): ' + d.toFixed(2));
    return d <= 10000;
}

function hasValueOf(x : unknown) : x is number|Date|Time {
    return typeof x === 'number' || x instanceof Date || x instanceof Time;
}

function editDistance(one : (string|unknown[]), two : (string|unknown[])) : number {
    if (typeof one === 'string' && typeof two === 'string') {
        if (one === two)
            return 0;
        if (one.indexOf(two) >= 0)
            return one.length - two.length;
        if (two.indexOf(one) >= 0)
            return two.length - one.length;
    }

    const R = one.length + 1;
    const C = two.length + 1;
    const matrix = new Array<number>(R * C);

    function set(i : number, j : number, v : number) : void {
        assert(i * C + j < R * C);
        matrix[i * C + j] = v;
    }

    function get(i : number, j : number) : number {
        assert(i * C + j < R * C);
        return matrix[i * C + j];
    }

    for (let j = 0; j < C; j++)
        set(0, j, j);
    for (let i = 1; i < R; i++)
        set(i, 0, i);
    for (let i = 1; i <= one.length; i++) {
        for (let j = 1; j <= two.length; j++) {
            if (one[i - 1] === two[j - 1])
                set(i, j, get(i - 1, j - 1));
            else
                set(i, j, 1 + Math.min(Math.min(get(i - 1, j), get(i, j - 1)), get(i - 1, j - 1)));
        }
    }

    return get(one.length, two.length);
}

function isDateLike(a : unknown) : a is Date|Temporal.ZonedDateTime|Temporal.Instant {
    return a instanceof Date || a instanceof Temporal.ZonedDateTime || a instanceof Temporal.Instant;
}
function toInstant(a : string|Date|Temporal.ZonedDateTime|Temporal.Instant) {
    if (typeof a === 'string')
        return Temporal.Instant.from(a);
    if (a instanceof Date)
        return toTemporalInstant.call(a);
    else if (a instanceof Temporal.ZonedDateTime)
        return a.toInstant();
    else
        return a;
}

export function equality(a : unknown, b : unknown) : boolean {
    if (a === b)
        return true;
    if (a === null || b === null) // they can't be both null because a !== b
        return false;
    if (a === undefined || b === undefined)
        return false;
    if (Number.isNaN(a) && Number.isNaN(b))
        return true;
    if ((isDateLike(a) && isDateLike(b)) ||
        (isDateLike(a) && typeof b === 'string') ||
        (typeof a === 'string' && isDateLike(b)))
        return toInstant(a).equals(toInstant(b));
    if (hasValueOf(a) && hasValueOf(b))
        return +a === +b;
    if (a instanceof Currency && b instanceof Currency)
        return a.value === b.value && a.code.toLowerCase() === b.code.toLowerCase();
    if (a instanceof Currency && typeof b === 'number')
        return +a === +b;
    if (b instanceof Currency && typeof a === 'number')
        return +a === +b;
    if (Location.isLocation(a) && Location.isLocation(b))
        return locationEquals(a, b);
    if (Entity.isEntity(a) && Entity.isEntity(b))
        return String(a) === String(b);
    if (a instanceof Ast.Example && b instanceof Ast.Example)
        return a.id === b.id;
    if (Array.isArray(a) && Array.isArray(b))
        return arrayEquals(a, b);
    if (typeof a === 'object' && typeof b === 'object') {
        assert(a !== null);
        assert(b !== null);
        return objectEquals(a, b);
    }

    return false;
}

export function like(a_ : unknown, b : string) : boolean {
    if (a_ instanceof Entity && a_.display)
        return like(a_.display, b);

    if (typeof a_ === 'string' && typeof b === 'string') {
        let a = a_.toLowerCase();
        a = a.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
        a = a.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');
        a = a.replace(/\p{White_Space}+/ug, ' ');
        a = a.trim();
        b = b.toLowerCase();
        b = b.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
        b = b.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');
        b = b.replace(/\p{White_Space}+/ug, ' ');
        b = b.trim();
        if (a.indexOf(b) >= 0)
            return true;
        for (const token_b of b.split(' ')) {
            let tokenFound = false;
            for (const token_a of a.split(' ')) {
                if (token_a === token_b || (editDistance(token_a, token_b) <= 1 && token_b.length > 1)) {
                    tokenFound = true;
                    break;
                }
            }
            if (!tokenFound)
                return false;
        }
        return true;
    }
    return false;
}

export function startsWith(a : unknown, b : unknown) : boolean {
    if (typeof a === 'string' && typeof b === 'string')
        return a.toLowerCase().startsWith(b.toLowerCase());
    return false;
}

export function endsWith(a : unknown, b : unknown) : boolean {
    if (typeof a === 'string' && typeof b === 'string')
        return a.toLowerCase().endsWith(b.toLowerCase());
    return false;
}

export function recurrentTimeSpecContains(spec : RecurrentTimeRule[],
                                          timeOrDate : Date|Temporal.ZonedDateTime|Temporal.PlainTime|Time) : boolean {
    assert(Array.isArray(spec));

    let contained = false;
    for (const rule of spec) {
        if (rule.contains(timeOrDate)) {
            if (rule.subtract)
                contained = false;
            else
                contained = true;
        }
    }
    return contained;
}

export function contains(a : unknown[]|null|undefined, b : unknown) : boolean {
    if (a === null || a === undefined)
        return false;
    return a.some((x) => equality(x, b));
}

// b is a substring of any element of a
export function containsLike(a : unknown[]|null|undefined, b : string) {
    if (a === null || a === undefined)
        return false;
    return a.some((x) => like(x, b));
}

// any element of b is a substring of a
export function inArrayLike(a : string, b : string[]|null|undefined) {
    if (b === null || b === undefined)
        return false;
    return b.some((x) => like(a, x));
}

export function getTime(d : Date) : Time {
    return new Time(d.getHours(), d.getMinutes(), d.getSeconds());
}

export function getCurrency(d : number) : Currency {
    return new Currency(d, 'usd'); //Assumes that default location is USA
}

// aggregations
export function sum(a : number, b : number) : number {
    return a + b;
}
export function max(a : number, b : number) : number {
    return Math.max(a, b);
}
export function min(a : number, b : number) : number {
    return Math.min(a, b);
}
export function argmax(value : number, previous : number) : boolean {
    return value > previous;
}
export function argmin(value : number, previous : number) : boolean {
    return value < previous;
}

// FIXME: replace with a faster implementation based on binary trees
// if we care
export class EqualitySet {
    store : unknown[];

    constructor() {
        this.store = [];
    }

    has(value : unknown) : boolean {
        for (const candidate of this.store) {
            if (equality(candidate, value))
                return true;
        }
        return false;
    }

    add(value : unknown) : void {
        for (const candidate of this.store) {
            if (equality(candidate, value))
                return;
        }
        this.store.push(value);
    }

    get size() : number {
        return this.store.length;
    }
}

type ArgMinMaxOp = (value : number, previous : number) => number;

export class ArgMinMaxState<T> {
    private _op : ArgMinMaxOp;
    private _total : number;
    private _filled : number;
    private _tuples : T[];
    private _outputTypes : string[];
    private _values : number[];
    private _base : number;

    constructor(op : ArgMinMaxOp,
                base : number,
                limit : number) {
        this._op = op;

        this._total = Math.max(base + limit - 1, 1);
        this._filled = 0;
        this._tuples = new Array(this._total);
        this._outputTypes = new Array(this._total);
        this._values = new Array(this._total);

        this._base = Math.max(base-1, 0);
    }

    *[Symbol.iterator]() : Generator<[string, unknown], void> {
        for (let i = this._base; i < this._filled; i++)
            yield [this._outputTypes[i], this._tuples[i]];
    }

    update(tuple : T, outputType : string, value : number) : void {
        for (let i = 0; i < this._filled; i++) {
            const candidate = this._values[i];
            if (this._op(value, candidate)) {
                // shift everything by one

                let last;
                if (this._filled < this._total) {
                    last = this._filled;
                    this._filled++;
                } else {
                    last = this._filled-1;
                }
                for (let j = last; j > i; j--) {
                    this._tuples[j] = this._tuples[j-1];
                    this._outputTypes[j] = this._outputTypes[j-1];
                    this._values[j] = this._values[j-1];
                }

                this._tuples[i] = tuple;
                this._outputTypes[i] = outputType;
                this._values[i] = value;
                return;
            }
        }

        if (this._filled < this._total) {
            this._tuples[this._filled] = tuple;
            this._outputTypes[this._filled] = outputType;
            this._values[this._filled] = value;
            this._filled ++;
        }
    }
}

export function count(x : unknown[]) : number {
    return x.length;
}

export function aggregateMax(array : number[]) : number {
    let value = -Infinity;
    for (const element of array)
        value = Math.max(element, value);
    return value;
}
export function aggregateMin(array : number[]) : number {
    let value = Infinity;
    for (const element of array)
        value = Math.min(element, value);
    return value;
}
export function aggregateSum(array : number[]) : number {
    let value = 0;
    for (const element of array)
        value += element;
    return value;
}
export function aggregateAvg(array : number[]) : number {
    let sum = 0;
    let count = 0;
    for (const element of array) {
        sum += element;
        count += 1;
    }
    return sum/count;
}
export function setTime(env : ExecEnvironment, d : Date|Temporal.ZonedDateTime|Temporal.Instant|null, t : Time|Temporal.PlainTime|null) : Date {
    let dtz;
    if (d === null)
        dtz = Temporal.Now.zonedDateTime('iso8601', env.timezone);
    else if (d instanceof Date)
        dtz = toTemporalInstant.call(d).toZonedDateTime({ timeZone: env.timezone, calendar: 'iso8601' });
    else if (d instanceof Temporal.Instant)
        dtz = d.toZonedDateTime({ timeZone: env.timezone, calendar: 'iso8601' });
    else
        dtz = d;

    if (t !== null)
        dtz = dtz.withPlainTime(t);

    // convert back to legacy JS Date for compatibility with existing code
    return new Date(dtz.epochMilliseconds);
}
export function dateAdd(date : Date|Temporal.Instant|Temporal.ZonedDateTime, offset : number) : Date {
    return new Date(toInstant(date).epochMilliseconds + offset);
}
export function dateSub(date : Date|Temporal.Instant|Temporal.ZonedDateTime, offset : number) : Date {
    return new Date(toInstant(date).epochMilliseconds - offset);
}

function timeToNumber(time : Time|Temporal.PlainTime) {
    if (time instanceof Temporal.PlainTime)
        return Time.fromTemporal(time).valueOf();
    else
        return time.valueOf();
}

export function timeAdd(time : Time|Temporal.PlainTime, offset : number) : Time {
    return Time.fromSeconds(timeToNumber(time) + Math.round(offset/1000));
}
export function timeSub(time : Time, offset : number) : Time {
    return Time.fromSeconds(timeToNumber(time) - Math.round(offset/1000));
}

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 * as Ast from '../ast';	2✔
25
26	import type { ExecEnvironment } from './exec_environment';
27	import {	2✔
28	LocationLike,
29	Location,
30	Entity,
31	Time,
32	Currency,
33	RecurrentTimeRule
34	} from './values';
35
36	// Implementations of the ThingTalk operators
37
38	function arrayEquals(a : unknown[], b : unknown[]) : boolean {
39	if (a.length !== b.length)	16✔
40	return false;	4✔
41
42	for (let i = 0; i < a.length; i++) {	12✔
43	if (!equality(a[i], b[i]))	16✔
44	return false;	2✔
45	}
46
47	return true;	10✔
48	}
49
50	function objectEquals<T1, T2>(a : T1, b : T2) : boolean {
51	const a_props = Object.getOwnPropertyNames(a) as Array<keyof T1>;	10✔
52	const b_props = Object.getOwnPropertyNames(b) as Array<keyof T2>;	10✔
53
54	if (a_props.length !== b_props.length)	10!
55	return false;	×
56
57	for (let i = 0; i < a_props.length; i ++) {	10✔
58	if (!equality(a[a_props[i]], b[a_props[i] as unknown as keyof T2]))	44✔
59	return false;	2✔
60	}
61
62	return true;	8✔
63	}
64
65	export function distance(a : LocationLike, b : LocationLike) : number {	2✔
66	const R = 6371000; // meters	×
67	const lat1 = a.y;	×
68	const lat2 = b.y;	×
69	const lon1 = a.x;	×
70	const lon2 = a.x;	×
71	function toRadians(deg : number) { return deg * Math.PI / 180.0; }	×
72
73	// formula courtesy of http://www.movable-type.co.uk/scripts/latlong.html
74	const φ1 = toRadians(lat1);	×
75	const φ2 = toRadians(lat2);	×
76	const Δφ = toRadians(lat2-lat1);	×
77	const Δλ = toRadians(lon2-lon1);	×
78
79	const x = Math.sin(Δφ/2) * Math.sin(Δφ/2) +	×
80	Math.cos(φ1) * Math.cos(φ2) *
81	Math.sin(Δλ/2) * Math.sin(Δλ/2);
82	const c = 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1-x));	×
83
84	return R * c;	×
85	}
86
87	function locationEquals(a : LocationLike, b : LocationLike) : boolean {
88	if (a === b)	12!
89	return true;	×
90	if (a.x === b.x && a.y === b.y)	12!
91	return true;	12✔
92	//console.log('Comparing locations', [a,b]);
93	const d = distance(a, b);	×
94	//console.log('Distance (m): ' + d.toFixed(2));
95	return d <= 10000;	×
96	}
97
98	function hasValueOf(x : unknown) : x is number\|Date\|Time {
99	return typeof x === 'number' \|\| x instanceof Date \|\| x instanceof Time;	248✔
100	}
101
102	function editDistance(one : (string\|unknown[]), two : (string\|unknown[])) : number {
103	if (typeof one === 'string' && typeof two === 'string') {	50!
104	if (one === two)	50!
105	return 0;	×
106	if (one.indexOf(two) >= 0)	50!
107	return one.length - two.length;	×
108	if (two.indexOf(one) >= 0)	50✔
109	return two.length - one.length;	10✔
110	}
111
112	const R = one.length + 1;	40✔
113	const C = two.length + 1;	40✔
114	const matrix = new Array<number>(R * C);	40✔
115
116	function set(i : number, j : number, v : number) : void {
117	assert(i * C + j < R * C);	1,776✔
118	matrix[i * C + j] = v;	1,776✔
119	}
120
121	function get(i : number, j : number) : number {
122	assert(i * C + j < R * C);	3,658✔
123	return matrix[i * C + j];	3,658✔
124	}
125
126	for (let j = 0; j < C; j++)	40✔
127	set(0, j, j);	274✔
128	for (let i = 1; i < R; i++)	40✔
129	set(i, 0, i);	220✔
130	for (let i = 1; i <= one.length; i++) {	40✔
131	for (let j = 1; j <= two.length; j++) {	220✔
132	if (one[i - 1] === two[j - 1])	1,282✔
133	set(i, j, get(i - 1, j - 1));	114✔
134	else
135	set(i, j, 1 + Math.min(Math.min(get(i - 1, j), get(i, j - 1)), get(i - 1, j - 1)));	1,168✔
136	}
137	}
138
139	return get(one.length, two.length);	40✔
140	}
141
142	function isDateLike(a : unknown) : a is Date\|Temporal.ZonedDateTime\|Temporal.Instant {
143	return a instanceof Date \|\| a instanceof Temporal.ZonedDateTime \|\| a instanceof Temporal.Instant;	460✔
144	}
145	function toInstant(a : string\|Date\|Temporal.ZonedDateTime\|Temporal.Instant) {
146	if (typeof a === 'string')	16✔
147	return Temporal.Instant.from(a);	4✔
148	if (a instanceof Date)	12!
149	return toTemporalInstant.call(a);	12✔
NEW 150	else if (a instanceof Temporal.ZonedDateTime)	×
NEW 151	return a.toInstant();	×
152	else
NEW 153	return a;	×
154	}
155
156	export function equality(a : unknown, b : unknown) : boolean {	2✔
157	if (a === b)	336✔
158	return true;	126✔
159	if (a === null \|\| b === null) // they can't be both null because a !== b	210✔
160	return false;	2✔
161	if (a === undefined \|\| b === undefined)	208!
162	return false;	×
163	if (Number.isNaN(a) && Number.isNaN(b))	208✔
164	return true;	2✔
165	if ((isDateLike(a) && isDateLike(b)) \|\|	206✔
166	(isDateLike(a) && typeof b === 'string') \|\|
167	(typeof a === 'string' && isDateLike(b)))
168	return toInstant(a).equals(toInstant(b));	8✔
169	if (hasValueOf(a) && hasValueOf(b))	198✔
170	return +a === +b;	44✔
171	if (a instanceof Currency && b instanceof Currency)	154✔
172	return a.value === b.value && a.code.toLowerCase() === b.code.toLowerCase();	16✔
173	if (a instanceof Currency && typeof b === 'number')	138✔
174	return +a === +b;	4✔
175	if (b instanceof Currency && typeof a === 'number')	134✔
176	return +a === +b;	4✔
177	if (Location.isLocation(a) && Location.isLocation(b))	130✔
178	return locationEquals(a, b);	12✔
179	if (Entity.isEntity(a) && Entity.isEntity(b))	118✔
180	return String(a) === String(b);	86✔
181	if (a instanceof Ast.Example && b instanceof Ast.Example)	32!
182	return a.id === b.id;	×
183	if (Array.isArray(a) && Array.isArray(b))	32✔
184	return arrayEquals(a, b);	16✔
185	if (typeof a === 'object' && typeof b === 'object') {	16✔
186	assert(a !== null);	10✔
187	assert(b !== null);	10✔
188	return objectEquals(a, b);	10✔
189	}
190
191	return false;	6✔
192	}
193
194	export function like(a_ : unknown, b : string) : boolean {	2✔
195	if (a_ instanceof Entity && a_.display)	46!
196	return like(a_.display, b);	×
197
198	if (typeof a_ === 'string' && typeof b === 'string') {	46!
199	let a = a_.toLowerCase();	46✔
200	a = a.normalize("NFD").replace(/[\u0300-\u036f]/g, "");	46✔
201	a = a.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');	46✔
202	a = a.replace(/\p{White_Space}+/ug, ' ');	46✔
203	a = a.trim();	46✔
204	b = b.toLowerCase();	46✔
205	b = b.normalize("NFD").replace(/[\u0300-\u036f]/g, "");	46✔
206	b = b.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');	46✔
207	b = b.replace(/\p{White_Space}+/ug, ' ');	46✔
208	b = b.trim();	46✔
209	if (a.indexOf(b) >= 0)	46✔
210	return true;	24✔
211	for (const token_b of b.split(' ')) {	22✔
212	let tokenFound = false;	30✔
213	for (const token_a of a.split(' ')) {	30✔
214	if (token_a === token_b \|\| (editDistance(token_a, token_b) <= 1 && token_b.length > 1)) {	56✔
215	tokenFound = true;	20✔
216	break;	20✔
217	}
218	}
219	if (!tokenFound)	30✔
220	return false;	10✔
221	}
222	return true;	12✔
223	}
224	return false;	×
225	}
226
227	export function startsWith(a : unknown, b : unknown) : boolean {	2✔
228	if (typeof a === 'string' && typeof b === 'string')	×
229	return a.toLowerCase().startsWith(b.toLowerCase());	×
230	return false;	×
231	}
232
233	export function endsWith(a : unknown, b : unknown) : boolean {	2✔
234	if (typeof a === 'string' && typeof b === 'string')	×
235	return a.toLowerCase().endsWith(b.toLowerCase());	×
236	return false;	×
237	}
238
239	export function recurrentTimeSpecContains(spec : RecurrentTimeRule[],	2✔
240	timeOrDate : Date\|Temporal.ZonedDateTime\|Temporal.PlainTime\|Time) : boolean {
241	assert(Array.isArray(spec));	×
242
243	let contained = false;	×
244	for (const rule of spec) {	×
245	if (rule.contains(timeOrDate)) {	×
246	if (rule.subtract)	×
247	contained = false;	×
248	else
249	contained = true;	×
250	}
251	}
252	return contained;	×
253	}
254
255	export function contains(a : unknown[]\|null\|undefined, b : unknown) : boolean {	2✔
256	if (a === null \|\| a === undefined)	×
257	return false;	×
258	return a.some((x) => equality(x, b));	×
259	}
260
261	// b is a substring of any element of a
262	export function containsLike(a : unknown[]\|null\|undefined, b : string) {	2✔
263	if (a === null \|\| a === undefined)	×
264	return false;	×
265	return a.some((x) => like(x, b));	×
266	}
267
268	// any element of b is a substring of a
269	export function inArrayLike(a : string, b : string[]\|null\|undefined) {	2✔
270	if (b === null \|\| b === undefined)	×
271	return false;	×
272	return b.some((x) => like(a, x));	×
273	}
274
275	export function getTime(d : Date) : Time {	2✔
276	return new Time(d.getHours(), d.getMinutes(), d.getSeconds());	×
277	}
278
279	export function getCurrency(d : number) : Currency {	2✔
280	return new Currency(d, 'usd'); //Assumes that default location is USA	×
281	}
282
283	// aggregations
284	export function sum(a : number, b : number) : number {	2✔
285	return a + b;	×
286	}
287	export function max(a : number, b : number) : number {	2✔
288	return Math.max(a, b);	×
289	}
290	export function min(a : number, b : number) : number {	2✔
291	return Math.min(a, b);	4✔
292	}
293	export function argmax(value : number, previous : number) : boolean {	2✔
294	return value > previous;	×
295	}
296	export function argmin(value : number, previous : number) : boolean {	2✔
297	return value < previous;	28✔
298	}
299
300	// FIXME: replace with a faster implementation based on binary trees
301	// if we care
302	export class EqualitySet {	2✔
303	store : unknown[];
304
305	constructor() {
306	this.store = [];	2✔
307	}
308
309	has(value : unknown) : boolean {
310	for (const candidate of this.store) {	×
311	if (equality(candidate, value))	×
312	return true;	×
313	}
314	return false;	×
315	}
316
317	add(value : unknown) : void {
318	for (const candidate of this.store) {	6✔
319	if (equality(candidate, value))	4✔
320	return;	2✔
321	}
322	this.store.push(value);	4✔
323	}
324
325	get size() : number {
326	return this.store.length;	2✔
327	}
328	}
329
330	type ArgMinMaxOp = (value : number, previous : number) => number;
331
332	export class ArgMinMaxState<T> {	2✔
333	private _op : ArgMinMaxOp;
334	private _total : number;
335	private _filled : number;
336	private _tuples : T[];
337	private _outputTypes : string[];
338	private _values : number[];
339	private _base : number;
340
341	constructor(op : ArgMinMaxOp,
342	base : number,
343	limit : number) {
344	this._op = op;	12✔
345
346	this._total = Math.max(base + limit - 1, 1);	12✔
347	this._filled = 0;	12✔
348	this._tuples = new Array(this._total);	12✔
349	this._outputTypes = new Array(this._total);	12✔
350	this._values = new Array(this._total);	12✔
351
352	this._base = Math.max(base-1, 0);	12✔
353	}
354
355	*[Symbol.iterator]() : Generator<[string, unknown], void> {
356	for (let i = this._base; i < this._filled; i++)	12✔
357	yield [this._outputTypes[i], this._tuples[i]];	18✔
358	}
359
360	update(tuple : T, outputType : string, value : number) : void {
361	for (let i = 0; i < this._filled; i++) {	36✔
362	const candidate = this._values[i];	28✔
363	if (this._op(value, candidate)) {	28✔
364	// shift everything by one
365
366	let last;
367	if (this._filled < this._total) {	18✔
368	last = this._filled;	14✔
369	this._filled++;	14✔
370	} else {
371	last = this._filled-1;	4✔
372	}
373	for (let j = last; j > i; j--) {	18✔
374	this._tuples[j] = this._tuples[j-1];	22✔
375	this._outputTypes[j] = this._outputTypes[j-1];	22✔
376	this._values[j] = this._values[j-1];	22✔
377	}
378
379	this._tuples[i] = tuple;	18✔
380	this._outputTypes[i] = outputType;	18✔
381	this._values[i] = value;	18✔
382	return;	18✔
383	}
384	}
385
386	if (this._filled < this._total) {	18✔
387	this._tuples[this._filled] = tuple;	14✔
388	this._outputTypes[this._filled] = outputType;	14✔
389	this._values[this._filled] = value;	14✔
390	this._filled ++;	14✔
391	}
392	}
393	}
394
395	export function count(x : unknown[]) : number {	2✔
396	return x.length;	×
397	}
398
399	export function aggregateMax(array : number[]) : number {	2✔
400	let value = -Infinity;	×
401	for (const element of array)	×
402	value = Math.max(element, value);	×
403	return value;	×
404	}
405	export function aggregateMin(array : number[]) : number {	2✔
406	let value = Infinity;	×
407	for (const element of array)	×
408	value = Math.min(element, value);	×
409	return value;	×
410	}
411	export function aggregateSum(array : number[]) : number {	2✔
412	let value = 0;	×
413	for (const element of array)	×
414	value += element;	×
415	return value;	×
416	}
417	export function aggregateAvg(array : number[]) : number {	2✔
418	let sum = 0;	×
419	let count = 0;	×
420	for (const element of array) {	×
421	sum += element;	×
422	count += 1;	×
423	}
424	return sum/count;	×
425	}
426	export function setTime(env : ExecEnvironment, d : Date\|Temporal.ZonedDateTime\|Temporal.Instant\|null, t : Time\|Temporal.PlainTime\|null) : Date {	2✔
427	let dtz;
428	if (d === null)	2!
NEW 429	dtz = Temporal.Now.zonedDateTime('iso8601', env.timezone);	×
430	else if (d instanceof Date)	2!
431	dtz = toTemporalInstant.call(d).toZonedDateTime({ timeZone: env.timezone, calendar: 'iso8601' });	2✔
NEW 432	else if (d instanceof Temporal.Instant)	×
NEW 433	dtz = d.toZonedDateTime({ timeZone: env.timezone, calendar: 'iso8601' });	×
434	else
NEW 435	dtz = d;	×
436
437	if (t !== null)	2!
438	dtz = dtz.withPlainTime(t);	2✔
439
440	// convert back to legacy JS Date for compatibility with existing code
441	return new Date(dtz.epochMilliseconds);	2✔
442	}
443	export function dateAdd(date : Date\|Temporal.Instant\|Temporal.ZonedDateTime, offset : number) : Date {	2✔
NEW 444	return new Date(toInstant(date).epochMilliseconds + offset);	×
445	}
446	export function dateSub(date : Date\|Temporal.Instant\|Temporal.ZonedDateTime, offset : number) : Date {	2✔
NEW 447	return new Date(toInstant(date).epochMilliseconds - offset);	×
448	}
449
450	function timeToNumber(time : Time\|Temporal.PlainTime) {
NEW 451	if (time instanceof Temporal.PlainTime)	×
NEW 452	return Time.fromTemporal(time).valueOf();	×
453	else
NEW 454	return time.valueOf();	×
455	}
456
457	export function timeAdd(time : Time\|Temporal.PlainTime, offset : number) : Time {	2✔
NEW 458	return Time.fromSeconds(timeToNumber(time) + Math.round(offset/1000));	×
459	}
460	export function timeSub(time : Time, offset : number) : Time {	2✔
NEW 461	return Time.fromSeconds(timeToNumber(time) - Math.round(offset/1000));	×
462	}

stanford-oval / thingtalk / 1535

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