stanford-oval / thingtalk / 932

pending completion

Build # 932

Build Type

Pull #217

travis-ci-com

Committed by

web-flow

Commit Message

Merge e1a833a85 into 6054aa112

Pull Request Pull Request #217: Relax entity checks in NN syntax

Run Details

4296 of 5755 branches covered (74.65%)

Branch coverage included in aggregate %.

17 of 25 new or added lines in 3 files covered. (68.0%)

151 existing lines in 1 file now uncovered.

8431 of 10129 relevant lines covered (83.24%)

1575.19 hits per line

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

71.67

/lib/builtin/primitive_ops.js

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

const Ast = require('../ast');

const BuiltinValues = require('./values');
const Location = BuiltinValues.Location;
const Entity = BuiltinValues.Entity;
const Time = BuiltinValues.Time;
const Currency = BuiltinValues.Currency;

// Implementations of the ThingTalk operators

function arrayEquals(a, b) {
    if (a.length !== b.length)
        return false;

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

    return true;
}

function objectEquals(a, b) {
    let a_props = Object.getOwnPropertyNames(a);
    let b_props = Object.getOwnPropertyNames(b);

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

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

    return true;
}

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

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

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

    return R * c;
}
module.exports.distance = distance;

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

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

function equalityTest(a, b) {
    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 (a instanceof Date && typeof b === 'string')
        return +a === +new Date(b);
    if (typeof a === 'string' && b instanceof Date)
        return +new Date(a) === +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 (a.feedId !== undefined)
        return a.feedId === b.feedId;
    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')
        return objectEquals(a, b);

    return false;
}
module.exports.equality = equalityTest;

function likeTest(a, b) {
    if (a.display)
        return likeTest(a.display, b);

    if (typeof a === 'string' && typeof b === 'string') {
        a = a.toLowerCase();
        b = b.toLowerCase();
        if (a.indexOf(b) >= 0)
            return true;
        if (a.replace(/'/g, ' ').indexOf(b.replace(/'/g, ' ')) >= 0)
            return true;
    }
    return false;
}
module.exports.like = likeTest;

function startsWith(a, b) {
    if (typeof a === 'string' && typeof b === 'string')
        return a.toLowerCase().startsWith(b.toLowerCase());
    return false;
}
module.exports.startsWith = startsWith;

function endsWith(a, b) {
    if (typeof a === 'string' && typeof b === 'string')
        return a.toLowerCase().endsWith(b.toLowerCase());
    return false;
}
module.exports.endsWith = endsWith;

function contains(a, b) {
    return a.some((x) => equalityTest(x, b));
}
module.exports.contains = contains;

// b is a substring of any element of a
function containsLike(a, b) {
    return a.some((x) => likeTest(x, b));
}
module.exports.containsLike = containsLike;

// any element of b is a substring of a
function inArrayLike(a, b) {
    return b.some((x) => likeTest(a, x));
}
module.exports.inArrayLike = inArrayLike;

function getTime(d) {
    return new Time(d.getHours(), d.getMinutes(), d.getSeconds());
}
module.exports.getTime = getTime;

function getCurrency(d) {
    return new Currency(d, 'usd'); //Assumes that default location is USA
}
module.exports.getCurrency = getCurrency;

// aggregations
module.exports.sum = function(a, b) {
    return a + b;
};
module.exports.max = function(a, b) {
    return Math.max(a, b);
};
module.exports.min = function(a, b) {
    return Math.min(a, b);
};
module.exports.argmax = function(value, previous) {
    return value > previous;
};
module.exports.argmin = function(value, previous) {
    return value < previous;
};

// FIXME: replace with a faster implementation based on binary trees
// if we care
class EqualitySet {
    constructor() {
        this.store = [];
    }

    has(value) {
        for (let candidate of this.store) {
            if (equalityTest(candidate, value))
                return true;
        }
        return false;
    }

    add(value) {
        for (let candidate of this.store) {
            if (equalityTest(candidate, value))
                return;
        }
        this.store.push(value);
    }

    get size() {
        return this.store.length;
    }
}
module.exports.EqualitySet = EqualitySet;

class ArgMinMaxState {
    constructor(op, field, base, limit) {
        this._op = op;
        this._field = field;

        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]() {
        for (let i = this._base; i < this._filled; i++)
            yield [this._outputTypes[i], this._tuples[i]];
    }

    update(tuple, outputType) {
        const value = tuple[this._field];

        for (let i = 0; i < this._filled; i++) {
            const candidate = this._tuples[i][this._field];
            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._tuples[i] = tuple;
                this._outputTypes[i] = outputType;
                return;
            }
        }

        if (this._filled < this._total) {
            this._tuples[this._filled] = tuple;
            this._outputTypes[this._filled] = outputType;
            this._filled ++;
        }
    }
}
module.exports.ArgMinMaxState = ArgMinMaxState;

module.exports.count = function count(x) {
    return x.length;
};

module.exports.aggregateMax = function aggregateMax(array) {
    let value = -Infinity;
    for (let element of array)
        value = Math.max(element, value);
    return value;
};
module.exports.aggregateMin = function aggregateMin(array) {
    let value = Infinity;
    for (let element of array)
        value = Math.min(element, value);
    return value;
};
module.exports.aggregateSum = function aggregateSum(array) {
    let value = 0;
    for (let element of array)
        value += element;
    return value;
};
module.exports.aggregateAvg = function aggregateAvg(array) {
    let sum = 0;
    let count = 0;
    for (let element of array) {
        sum += element;
        count += 1;
    }
    return sum/count;
};
module.exports.dateAdd = function(date, offset) {
    return new Date(date.getTime() + offset);
};
module.exports.dateSub = function(date, offset) {
    return new Date(date.getTime() - offset);
};
module.exports.timeAdd = function(time, offset) {
    return Time.fromSeconds(time + Math.round(offset/1000));
};
module.exports.timeSub = function(time, offset) {
    return Time.fromSeconds(time - Math.round(offset/1000));
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2015-2018 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 Ast = require('../ast');	2✔
13
14	const BuiltinValues = require('./values');	2✔
15	const Location = BuiltinValues.Location;	2✔
16	const Entity = BuiltinValues.Entity;	2✔
17	const Time = BuiltinValues.Time;	2✔
18	const Currency = BuiltinValues.Currency;	2✔
19
20	// Implementations of the ThingTalk operators
21
22	function arrayEquals(a, b) {
23	if (a.length !== b.length)	12✔
24	return false;	4✔
25
26	for (var i = 0; i < a.length; i++) {	8✔
27	if (!equalityTest(a[i], b[i]))	12✔
28	return false;	2✔
29	}
30
31	return true;	6✔
32	}
33
34	function objectEquals(a, b) {
35	let a_props = Object.getOwnPropertyNames(a);	6✔
36	let b_props = Object.getOwnPropertyNames(b);	6✔
37
38	if (a_props.length !== b_props.length)	6!
39	return false;	×
40
41	for (let i = 0; i < a_props.length; i ++) {	6✔
42	if (!equalityTest(a[a_props[i]], b[a_props[i]]))	12✔
43	return false;	2✔
44	}
45
46	return true;	4✔
47	}
48
49	function distance(a, b) {
50	const R = 6371000; // meters	×
51	var lat1 = a.y;	×
52	var lat2 = b.y;	×
53	var lon1 = a.x;	×
54	var lon2 = a.x;	×
55	function toRadians(deg) { return deg * Math.PI / 180.0; }	×
56
57	// formula courtesy of http://www.movable-type.co.uk/scripts/latlong.html
58	var φ1 = toRadians(lat1);	×
59	var φ2 = toRadians(lat2);	×
60	var Δφ = toRadians(lat2-lat1);	×
61	var Δλ = toRadians(lon2-lon1);	×
62
63	var x = Math.sin(Δφ/2) * Math.sin(Δφ/2) +	×
64	Math.cos(φ1) * Math.cos(φ2) *
65	Math.sin(Δλ/2) * Math.sin(Δλ/2);
66	var c = 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1-x));	×
67
68	return R * c;	×
69	}
70	module.exports.distance = distance;	2✔
71
72	function locationEquals(a, b) {
73	if (a === b)	12!
74	return true;	×
75	if (a.x === b.x && a.y === b.y)	12!
76	return true;	12✔
77	//console.log('Comparing locations', [a,b]);
78	var d = distance(a, b);	×
79	//console.log('Distance (m): ' + d.toFixed(2));
80	return d <= 10000;	×
81	}
82
83	function hasValueOf(x) {
84	return typeof x === 'number' \|\| x instanceof Date \|\| x instanceof Time;	230✔
85	}
86
87	function equalityTest(a, b) {
88	if (a === b)	296✔
89	return true;	102✔
90	if (a === null \|\| b === null) // they can't be both null because a !== b	194✔
91	return false;	2✔
92	if (a === undefined \|\| b === undefined)	192!
93	return false;	×
94	if (Number.isNaN(a) && Number.isNaN(b))	192✔
95	return true;	2✔
96	if (a instanceof Date && typeof b === 'string')	190✔
97	return +a === +new Date(b);	2✔
98	if (typeof a === 'string' && b instanceof Date)	188✔
99	return +new Date(a) === +b;	2✔
100	if (hasValueOf(a) && hasValueOf(b))	186✔
101	return +a === +b;	38✔
102	if (a instanceof Currency && b instanceof Currency)	148✔
103	return a.value === b.value && a.code.toLowerCase() === b.code.toLowerCase();	16✔
104	if (a instanceof Currency && typeof b === 'number')	132✔
105	return +a === +b;	4✔
106	if (b instanceof Currency && typeof a === 'number')	128✔
107	return +a === +b;	4✔
108	if (a.feedId !== undefined)	124!
109	return a.feedId === b.feedId;	×
110	if (Location.isLocation(a) && Location.isLocation(b))	124✔
111	return locationEquals(a, b);	12✔
112	if (Entity.isEntity(a) && Entity.isEntity(b))	112✔
113	return String(a) === String(b);	88✔
114	if (a instanceof Ast.Example && b instanceof Ast.Example)	24!
115	return a.id === b.id;	×
116	if (Array.isArray(a) && Array.isArray(b))	24✔
117	return arrayEquals(a, b);	12✔
118	if (typeof a === 'object' && typeof b === 'object')	12✔
119	return objectEquals(a, b);	6✔
120
121	return false;	6✔
122	}
123	module.exports.equality = equalityTest;	2✔
124
125	function likeTest(a, b) {
126	if (a.display)	14!
127	return likeTest(a.display, b);	×
128
129	if (typeof a === 'string' && typeof b === 'string') {	14!
130	a = a.toLowerCase();	14✔
131	b = b.toLowerCase();	14✔
132	if (a.indexOf(b) >= 0)	14✔
133	return true;	8✔
134	if (a.replace(/'/g, ' ').indexOf(b.replace(/'/g, ' ')) >= 0)	6!
NEW 135	return true;	×
136	}
137	return false;	6✔
138	}
139	module.exports.like = likeTest;	2✔
140
141	function startsWith(a, b) {
142	if (typeof a === 'string' && typeof b === 'string')	×
143	return a.toLowerCase().startsWith(b.toLowerCase());	×
144	return false;	×
145	}
146	module.exports.startsWith = startsWith;	2✔
147
148	function endsWith(a, b) {
149	if (typeof a === 'string' && typeof b === 'string')	×
150	return a.toLowerCase().endsWith(b.toLowerCase());	×
151	return false;	×
152	}
153	module.exports.endsWith = endsWith;	2✔
154
155	function contains(a, b) {
156	return a.some((x) => equalityTest(x, b));	×
157	}
158	module.exports.contains = contains;	2✔
159
160	// b is a substring of any element of a
161	function containsLike(a, b) {
162	return a.some((x) => likeTest(x, b));	×
163	}
164	module.exports.containsLike = containsLike;	2✔
165
166	// any element of b is a substring of a
167	function inArrayLike(a, b) {
168	return b.some((x) => likeTest(a, x));	×
169	}
170	module.exports.inArrayLike = inArrayLike;	2✔
171
172	function getTime(d) {
173	return new Time(d.getHours(), d.getMinutes(), d.getSeconds());	×
174	}
175	module.exports.getTime = getTime;	2✔
176
177	function getCurrency(d) {
178	return new Currency(d, 'usd'); //Assumes that default location is USA	×
179	}
180	module.exports.getCurrency = getCurrency;	2✔
181
182	// aggregations
183	module.exports.sum = function(a, b) {	2✔
184	return a + b;	×
185	};
186	module.exports.max = function(a, b) {	2✔
187	return Math.max(a, b);	×
188	};
189	module.exports.min = function(a, b) {	2✔
190	return Math.min(a, b);	4✔
191	};
192	module.exports.argmax = function(value, previous) {	2✔
193	return value > previous;	×
194	};
195	module.exports.argmin = function(value, previous) {	2✔
196	return value < previous;	28✔
197	};
198
199	// FIXME: replace with a faster implementation based on binary trees
200	// if we care
201	class EqualitySet {
202	constructor() {
203	this.store = [];	2✔
204	}
205
206	has(value) {
207	for (let candidate of this.store) {	×
208	if (equalityTest(candidate, value))	×
209	return true;	×
210	}
211	return false;	×
212	}
213
214	add(value) {
215	for (let candidate of this.store) {	6✔
216	if (equalityTest(candidate, value))	4✔
217	return;	2✔
218	}
219	this.store.push(value);	4✔
220	}
221
222	get size() {
223	return this.store.length;	2✔
224	}
225	}
226	module.exports.EqualitySet = EqualitySet;	2✔
227
228	class ArgMinMaxState {
229	constructor(op, field, base, limit) {
230	this._op = op;	12✔
231	this._field = field;	12✔
232
233	this._total = Math.max(base + limit - 1, 1);	12✔
234	this._filled = 0;	12✔
235	this._tuples = new Array(this._total);	12✔
236	this._outputTypes = new Array(this._total);	12✔
237	this._values = new Array(this._total);	12✔
238
239	this._base = Math.max(base-1, 0);	12✔
240	}
241
242	*[Symbol.iterator]() {
243	for (let i = this._base; i < this._filled; i++)	12✔
244	yield [this._outputTypes[i], this._tuples[i]];	18✔
245	}
246
247	update(tuple, outputType) {
248	const value = tuple[this._field];	36✔
249
250	for (let i = 0; i < this._filled; i++) {	36✔
251	const candidate = this._tuples[i][this._field];	28✔
252	if (this._op(value, candidate)) {	28✔
253	// shift everything by one
254
255	let last;
256	if (this._filled < this._total) {	18✔
257	last = this._filled;	14✔
258	this._filled++;	14✔
259	} else {
260	last = this._filled-1;	4✔
261	}
262	for (let j = last; j > i; j--) {	18✔
263	this._tuples[j] = this._tuples[j-1];	22✔
264	this._outputTypes[j] = this._outputTypes[j-1];	22✔
265	}
266
267	this._tuples[i] = tuple;	18✔
268	this._outputTypes[i] = outputType;	18✔
269	return;	18✔
270	}
271	}
272
273	if (this._filled < this._total) {	18✔
274	this._tuples[this._filled] = tuple;	14✔
275	this._outputTypes[this._filled] = outputType;	14✔
276	this._filled ++;	14✔
277	}
278	}
279	}
280	module.exports.ArgMinMaxState = ArgMinMaxState;	2✔
281
282	module.exports.count = function count(x) {	2✔
283	return x.length;	×
284	};
285
286	module.exports.aggregateMax = function aggregateMax(array) {	2✔
287	let value = -Infinity;	×
288	for (let element of array)	×
289	value = Math.max(element, value);	×
290	return value;	×
291	};
292	module.exports.aggregateMin = function aggregateMin(array) {	2✔
293	let value = Infinity;	×
294	for (let element of array)	×
295	value = Math.min(element, value);	×
296	return value;	×
297	};
298	module.exports.aggregateSum = function aggregateSum(array) {	2✔
299	let value = 0;	×
300	for (let element of array)	×
301	value += element;	×
302	return value;	×
303	};
304	module.exports.aggregateAvg = function aggregateAvg(array) {	2✔
305	let sum = 0;	×
306	let count = 0;	×
307	for (let element of array) {	×
308	sum += element;	×
309	count += 1;	×
310	}
311	return sum/count;	×
312	};
313	module.exports.dateAdd = function(date, offset) {	2✔
314	return new Date(date.getTime() + offset);	×
315	};
316	module.exports.dateSub = function(date, offset) {	2✔
317	return new Date(date.getTime() - offset);	×
318	};
319	module.exports.timeAdd = function(time, offset) {	2✔
320	return Time.fromSeconds(time + Math.round(offset/1000));	×
321	};
322	module.exports.timeSub = function(time, offset) {	2✔
323	return Time.fromSeconds(time - Math.round(offset/1000));	×
324	};

stanford-oval / thingtalk / 932

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