stanford-oval / thingtalk / 991

pending completion

Build # 991

Build Type

Pull #240

travis-ci-com

Committed by

web-flow

Commit Message

Merge d9ff353ad into 5e815cadb

Pull Request Pull Request #240: Fix normalization of nested compute tables

Run Details

4360 of 5803 branches covered (75.13%)

Branch coverage included in aggregate %.

29 of 32 new or added lines in 2 files covered. (90.63%)

2 existing lines in 2 files now uncovered.

8555 of 10236 relevant lines covered (83.58%)

1565.86 hits per line

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

73.45

/lib/utils.js

// -*- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2016-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>
"use strict";

function makeIndex(args) {
    var index = {};
    var i = 0;
    for (var a of args)
        index[a] = i++;
    return index;
}

function clean(name) {
    if (/^[vwgp]_/.test(name))
        name = name.substr(2);
    return name.replace(/_/g, ' ').replace(/([^A-Z ])([A-Z])/g, '$1 $2').toLowerCase();
}

function cleanKind(kind) {
    // thingengine.phone -> phone
    if (kind.startsWith('org.thingpedia.builtin.thingengine.'))
        kind = kind.substr('org.thingpedia.builtin.thingengine.'.length);
    // org.thingpedia.builtin.omlet -> omlet
    if (kind.startsWith('org.thingpedia.builtin.'))
        kind = kind.substr('org.thingpedia.builtin.'.length);
    // org.thingpedia.weather -> weather
    if (kind.startsWith('org.thingpedia.'))
        kind = kind.substr('org.thingpedia.'.length);
    // io.home-assistant.battery -> battery
    if (kind.startsWith('io.home-assistant.'))
        kind = kind.substr('io.home-assistant.'.length);
    // com.xkcd -> xkcd
    if (kind.startsWith('com.'))
        kind = kind.substr('com.'.length);
    if (kind.startsWith('gov.'))
        kind = kind.substr('gov.'.length);
    if (kind.startsWith('org.'))
        kind = kind.substr('org.'.length);
    if (kind.startsWith('uk.co.'))
        kind = kind.substr('uk.co.'.length);
    kind = kind.replace(/[.-]/g, ' ');
    return clean(kind);
}

// this regexp is similar to the one in runtime/formatter.js, but it does not allow '%' as an option
// FIXME: unify
const PARAM_REGEX = /\$(?:\$|([a-zA-Z0-9_]+(?![a-zA-Z0-9_]))|{([a-zA-Z0-9_]+)(?::([a-zA-Z0-9_]+))?})/;

function* split(pattern, regexp) {
    // a split that preserves capturing parenthesis

    let clone = new RegExp(regexp, 'g');
    let match = clone.exec(pattern);

    let i = 0;
    while (match !== null) {
        if (match.index > i)
            yield pattern.substring(i, match.index);
        yield match;
        i = clone.lastIndex;
        match = clone.exec(pattern);
    }
    if (i < pattern.length)
        yield pattern.substring(i, pattern.length);
}

function getScalarExpressionName(ast) {
    if (ast.isVarRef)
        return ast.name;
    if (ast.isComputation && /^[a-zA-Z0-9]+$/.test(ast.op))
        return ast.op;
    else if (ast.isFilter || ast.isArrayField)
        return getScalarExpressionName(ast.value);
    else
        return 'result';
}

module.exports = {
    splitParams(utterance) {
        return Array.from(split(utterance, PARAM_REGEX));
    },
    split,
    makeIndex,
    clean,
    cleanKind,

    getSchemaForSelector(schemaRetriever, type, name, schemaType, getMeta = false, classes = {}) {
        if (type in classes) {
            let where = schemaRetriever._where(schemaType);
            if (!classes[type][where][name])
                throw new TypeError("Schema " + type + " has no " + where + " " + name);
            return Promise.resolve(classes[type][where][name]);
        }
        if (getMeta)
            return schemaRetriever.getMeta(type, schemaType, name);
        else
            return schemaRetriever.getSchemaAndNames(type, schemaType, name);
    },

    isUnaryTableToTableOp(table) {
        return table.isFilter ||
            table.isProjection ||
            table.isCompute ||
            table.isAlias ||
            table.isAggregation ||
            table.isSort ||
            table.isIndex ||
            table.isSlice;
    },
    isUnaryStreamToTableOp(table) {
        return false;
    },
    isUnaryStreamToStreamOp(stream) {
        return stream.isEdgeNew ||
            stream.isEdgeFilter ||
            stream.isFilter ||
            stream.isProjection ||
            stream.isCompute ||
            stream.isAlias;
    },
    isUnaryTableToStreamOp(stream) {
        return stream.isMonitor;
    },

    getScalarExpressionName
};

1	// -- mode: js; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2016-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	"use strict";
21
22	function makeIndex(args) {
23	var index = {};	×
24	var i = 0;	×
25	for (var a of args)	×
26	index[a] = i++;	×
27	return index;	×
28	}
29
30	function clean(name) {
31	if (/^[vwgp]_/.test(name))	111,892✔
32	name = name.substr(2);	84✔
33	return name.replace(/_/g, ' ').replace(/([^A-Z ])([A-Z])/g, '$1 $2').toLowerCase();	111,892✔
34	}
35
36	function cleanKind(kind) {
37	// thingengine.phone -> phone
38	if (kind.startsWith('org.thingpedia.builtin.thingengine.'))	266✔
39	kind = kind.substr('org.thingpedia.builtin.thingengine.'.length);	24✔
40	// org.thingpedia.builtin.omlet -> omlet
41	if (kind.startsWith('org.thingpedia.builtin.'))	266!
42	kind = kind.substr('org.thingpedia.builtin.'.length);	×
43	// org.thingpedia.weather -> weather
44	if (kind.startsWith('org.thingpedia.'))	266✔
45	kind = kind.substr('org.thingpedia.'.length);	18✔
46	// io.home-assistant.battery -> battery
47	if (kind.startsWith('io.home-assistant.'))	266!
48	kind = kind.substr('io.home-assistant.'.length);	×
49	// com.xkcd -> xkcd
50	if (kind.startsWith('com.'))	266✔
51	kind = kind.substr('com.'.length);	190✔
52	if (kind.startsWith('gov.'))	266!
53	kind = kind.substr('gov.'.length);	×
54	if (kind.startsWith('org.'))	266✔
55	kind = kind.substr('org.'.length);	8✔
56	if (kind.startsWith('uk.co.'))	266✔
57	kind = kind.substr('uk.co.'.length);	2✔
58	kind = kind.replace(/[.-]/g, ' ');	266✔
59	return clean(kind);	266✔
60	}
61
62	// this regexp is similar to the one in runtime/formatter.js, but it does not allow '%' as an option
63	// FIXME: unify
64	const PARAM_REGEX = /\$(?:\$\|([a-zA-Z0-9_]+(?![a-zA-Z0-9_]))\|{([a-zA-Z0-9_]+)(?::([a-zA-Z0-9_]+))?})/;	2✔
65
66	function* split(pattern, regexp) {
67	// a split that preserves capturing parenthesis
68
69	let clone = new RegExp(regexp, 'g');	×
70	let match = clone.exec(pattern);	×
71
72	let i = 0;	×
73	while (match !== null) {	×
74	if (match.index > i)	×
75	yield pattern.substring(i, match.index);	×
76	yield match;	×
77	i = clone.lastIndex;	×
78	match = clone.exec(pattern);	×
79	}
80	if (i < pattern.length)	×
81	yield pattern.substring(i, pattern.length);	×
82	}
83
84	function getScalarExpressionName(ast) {
85	if (ast.isVarRef)	144✔
86	return ast.name;	10✔
87	if (ast.isComputation && /^[a-zA-Z0-9]+$/.test(ast.op))	134✔
88	return ast.op;	70✔
89	else if (ast.isFilter \|\| ast.isArrayField)	64✔
90	return getScalarExpressionName(ast.value);	10✔
91	else
92	return 'result';	54✔
93	}
94
95	module.exports = {	2✔
96	splitParams(utterance) {
97	return Array.from(split(utterance, PARAM_REGEX));	×
98	},
99	split,
100	makeIndex,
101	clean,
102	cleanKind,
103
104	getSchemaForSelector(schemaRetriever, type, name, schemaType, getMeta = false, classes = {}) {	×
105	if (type in classes) {	2,074✔
106	let where = schemaRetriever._where(schemaType);	80✔
107	if (!classes[type][where][name])	80✔
108	throw new TypeError("Schema " + type + " has no " + where + " " + name);	2✔
109	return Promise.resolve(classes[type][where][name]);	78✔
110	}
111	if (getMeta)	1,994✔
112	return schemaRetriever.getMeta(type, schemaType, name);	596✔
113	else
114	return schemaRetriever.getSchemaAndNames(type, schemaType, name);	1,398✔
115	},
116
117	isUnaryTableToTableOp(table) {
118	return table.isFilter \|\|	2,136✔
119	table.isProjection \|\|
120	table.isCompute \|\|
121	table.isAlias \|\|
122	table.isAggregation \|\|
123	table.isSort \|\|
124	table.isIndex \|\|
125	table.isSlice;
126	},
127	isUnaryStreamToTableOp(table) {
UNCOV 128	return false;	×
129	},
130	isUnaryStreamToStreamOp(stream) {
131	return stream.isEdgeNew \|\|	866✔
132	stream.isEdgeFilter \|\|
133	stream.isFilter \|\|
134	stream.isProjection \|\|
135	stream.isCompute \|\|
136	stream.isAlias;
137	},
138	isUnaryTableToStreamOp(stream) {
139	return stream.isMonitor;	694✔
140	},
141
142	getScalarExpressionName
143	};

stanford-oval / thingtalk / 991

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