1581

pending completion

Build # 1581

Build Type

push

travis-ci-com

Committed by

gcampax

Commit Message

v2.1.0-alpha.10

Run Details

4658 of 6503 branches covered (71.63%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

169 existing lines in 7 files now uncovered.

10530 of 13011 relevant lines covered (80.93%)

50337.43 hits per line

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

70.44

/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,
    StringLike
} 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 = b.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 <= 2500;
}

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

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.valueOf() === b.valueOf();
    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;
}

function defaultLikeTest(a : string, b : string) : boolean {
    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;
}

function anyToString(a : unknown) {
    if (a === undefined)
        return 'undefined';
    if (a === null)
        return 'null';
    return (a as string).toString();
}

export function like(a : unknown, b : unknown) : boolean {
    if (a === undefined || a === null ||
        b === undefined || b === null)
        return false;

    if (a instanceof Entity) {
        if (a.softmatch)
            return a.softmatch(anyToString(b));
        if (a.display)
            return defaultLikeTest(a.display, anyToString(b));
        return false;
    }

    if (a instanceof StringLike) {
        if (a.softmatch)
            return a.softmatch(anyToString(b));
    }

    return defaultLikeTest(anyToString(a), anyToString(b));
}

export function startsWith(a : unknown, b : unknown) : boolean {
    return anyToString(a).toLowerCase().startsWith(anyToString(b).toLowerCase());
}

export function endsWith(a : unknown, b : unknown) : boolean {
    return anyToString(a).toLowerCase().endsWith(anyToString(b).toLowerCase());
}

export function recurrentTimeSpecContains(env : ExecEnvironment,
                                          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, env.timezone)) {
            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;
    }
}

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

stanford-oval / thingtalk / 1581

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