1507

pending completion

Build # 1507

Build Type

Pull #380

travis-ci-com

Committed by

web-flow

Commit Message

Merge 55657076b into 73931d76a

Pull Request Pull Request #380: Bring back join

Run Details

4585 of 6413 branches covered (71.5%)

Branch coverage included in aggregate %.

141 of 147 new or added lines in 10 files covered. (95.92%)

57 existing lines in 1 file now uncovered.

10491 of 12946 relevant lines covered (81.04%)

48438.01 hits per line

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

90.83

/lib/new-syntax/pretty.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2019-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 { stringEscape } from '../utils/escaping';
import {
    ConstantToken,
    TokenStream
} from './tokenstream';
import {
    StringLikeEntityType,
} from '../entities';

function simpleEntity<K extends StringLikeEntityType>(token : ConstantToken<K, string>, type : string) {
    return stringEscape(token.value) + '^^' + type;
}

const BASIC_INDENT = 2;

export function prettyprint(tokens : TokenStream) : string {
    let buffer = '';
    let indent = '';
    let needsIndent = true;
    const tabStops : string[] = [];

    function getColumn() {
        const newLine = buffer.lastIndexOf('\n');
        const lastLine = buffer.substring(newLine + 1);
        return lastLine.length;
    }

    for (const token of tokens) {
        /*if (typeof token === 'string' && token.startsWith(':') && token !== ':' && token !== '::') {
            // type annotation
            buffer += ' : ' + token.substring(1);
            continue;
        }*/

        // handle the formatting pseudo-tokens first
        switch (String(token)) {
        case ' ': // explicitly add a space
            buffer += ' ';
            continue;

        case '\t+': // increase basic indentation
            if (tabStops.length > 0)
                tabStops[tabStops.length-1] += ' '.repeat(BASIC_INDENT);
            else
                indent += ' '.repeat(BASIC_INDENT);
            continue;

        case '\t-': // decrease basic indentation
            if (tabStops.length > 0) {
                const lastStop = tabStops[tabStops.length-1];
                tabStops[tabStops.length-1] = lastStop.substring(0, lastStop.length - BASIC_INDENT);
            } else {
                indent = indent.substring(0, indent.length - BASIC_INDENT);
            }
            continue;

        case '\t=+': // add a tab stop at the current position
            tabStops.push(' '.repeat(getColumn()));
            continue;

        case '\t=-': // remove a previously added tab stop
            tabStops.pop();
            continue;

        case '\n-': // remove the last newline
            if (buffer.endsWith('\n'))
                buffer = buffer.substring(0, buffer.length-1);
            continue;

        case '\n':
            // remove an extra space if we just added it
            if (buffer.endsWith(' '))
                buffer = buffer.substring(0, buffer.length-1);
            buffer += '\n';
            needsIndent = true;
            continue;
        }

        if (/[ \n\t]/.test(String(token)))
            throw new Error(`Invalid control token "${token}"`);

        if (needsIndent) {
            if (tabStops.length > 0)
                buffer += tabStops[tabStops.length-1];
            else
                buffer += indent;
            needsIndent = false;
        }

        // convert literals/constants back to their surface representation
        if (token instanceof ConstantToken) {
            const constant = token;

            switch (constant.name) {
            case 'QUOTED_STRING':
                buffer += stringEscape(constant.value);
                break;
            case 'NUMBER':
                buffer += String(constant.value);
                break;
            case 'MEASURE': {
                const measure = constant.value;
                buffer += String(measure.value) + measure.unit;
                break;
            }
            case 'CURRENCY': {
                const currency = constant.value;
                buffer += String(currency.value) + '$' + currency.unit;
                break;
            }
            case 'LOCATION': {
                const location = constant.value;

                if (Number.isNaN(location.latitude) && Number.isNaN(location.longitude))
                    buffer += `new Location(${stringEscape(location.display)})`;
                else if (location.display !== null)
                    buffer += `new Location(${location.latitude}, ${location.longitude}, ${stringEscape(location.display)})`;
                else
                    buffer += `new Location(${location.latitude}, ${location.longitude})`;
                break;
            }
            case 'DATE': {
                const date = constant.value;
                buffer += `new Date(${stringEscape(date.toISOString())})`;
                break;
            }
            case 'TIME': {
                const time = constant.value;
                if (time.second !== 0)
                    buffer += `new Time(${time.hour}, ${time.minute}, ${time.second})`;
                else
                    buffer += `new Time(${time.hour}, ${time.minute})`;
                break;
            }
            case 'PICTURE':
                buffer += simpleEntity(constant, 'tt:picture');
                break;
            case 'USERNAME':
                buffer += simpleEntity(constant, 'tt:username');
                break;
            case 'HASHTAG':
                buffer += simpleEntity(constant, 'tt:hashtag');
                break;
            case 'URL':
                buffer += simpleEntity(constant, 'tt:url');
                break;
            case 'PHONE_NUMBER':
                buffer += simpleEntity(constant, 'tt:phone_number');
                break;
            case 'EMAIL_ADDRESS':
                buffer += simpleEntity(constant, 'tt:email_address');
                break;
            case 'PATH_NAME':
                buffer += simpleEntity(constant, 'tt:path_name');
                break;
            case 'GENERIC_ENTITY': {
                const entity = constant.value;
                if (entity.value === null)
                    buffer += 'null';
                else
                    buffer += stringEscape(entity.value);
                buffer += '^^' + entity.type;
                if (entity.display !== null)
                    buffer += '(' + stringEscape(entity.display) + ')';
                break;
            }
            }

            continue;
        }

        // now the actual tokens
        switch (token) {
        case ')':
            // eat a space if we're closing an enum and we had a keyword that introduced a space
            if (/\benum\([a-z]+ $/.test(buffer))
                buffer = buffer.substring(0, buffer.length-1);
            buffer += ')';
            break;

        case '*':
            if (buffer.endsWith('[')) // projection
                buffer += token;
            else // multiplication
                buffer += (buffer.endsWith(' ') ? '' : ' ') + token + ' ';
            break;

        // add a space before and after certain operators
        case ':':
        case '+':
        case '-':
        case '/':
        case '%':
        case '**':
        case '==':
        case '>=':
        case '<=':
        case '>':
        case '<':
        case '=~':
        case '~=':
        case '||':
        case '&&':
        case '::':
        case '=>':
            buffer += ' ' + token + ' ';
            break;

        // add a space after the comma and certain keywords,
        case ',':
        case 'abstract':
        case 'class':
        case 'const':
        case 'dataset':
        case 'enum':
        case 'if':
        case 'import':
        case 'in':
        case 'for':
        case 'function':
        case 'let':
        case 'list':
        case 'mixin':
        case 'monitorable':
        case 'new':
        case 'opt':
        case 'out':
        case 'req':
        case 'return':
        case 'switch':
        case 'until':
        case 'when':
        case 'while':
        case '$dialogue':
        case '$policy':
            buffer += token;
            if (!buffer.endsWith('enum '))
                buffer += ' ';
            break;

        // add a space BEFORE and AFTER filter, with, of, and as
        // this is necessary because they can follow a variable name immediately
        case 'with':
        case 'filter':
        case 'of':
        case 'as':
        case 'extends':
        case 'join':
        case 'on':
            if (buffer.endsWith('enum '))
                buffer += token;
            else
                buffer += ' ' + token + ' ';
            break;

        // the following keywords DO NOT receive a space: null, true, false, sort

        // other tokens
        default:
            buffer += token;
        }
    }

    return buffer.trim();
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2019-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 { stringEscape } from '../utils/escaping';	2✔
22	import {	2✔
23	ConstantToken,
24	TokenStream
25	} from './tokenstream';
26	import {
27	StringLikeEntityType,
28	} from '../entities';
29
30	function simpleEntity<K extends StringLikeEntityType>(token : ConstantToken<K, string>, type : string) {
31	return stringEscape(token.value) + '^^' + type;	448✔
32	}
33
34	const BASIC_INDENT = 2;	2✔
35
36	export function prettyprint(tokens : TokenStream) : string {	2✔
37	let buffer = '';	3,416✔
38	let indent = '';	3,416✔
39	let needsIndent = true;	3,416✔
40	const tabStops : string[] = [];	3,416✔
41
42	function getColumn() {
43	const newLine = buffer.lastIndexOf('\n');	1,484✔
44	const lastLine = buffer.substring(newLine + 1);	1,484✔
45	return lastLine.length;	1,484✔
46	}
47
48	for (const token of tokens) {	3,416✔
49	/*if (typeof token === 'string' && token.startsWith(':') && token !== ':' && token !== '::') {
50	// type annotation
51	buffer += ' : ' + token.substring(1);
52	continue;
53	}*/
54
55	// handle the formatting pseudo-tokens first
56	switch (String(token)) {	131,302✔
57	case ' ': // explicitly add a space	27,512!
58	buffer += ' ';	4,024✔
59	continue;	4,024✔
60
61	case '\t+': // increase basic indentation
62	if (tabStops.length > 0)	2,116✔
63	tabStops[tabStops.length-1] += ' '.repeat(BASIC_INDENT);	514✔
64	else
65	indent += ' '.repeat(BASIC_INDENT);	1,602✔
66	continue;	2,116✔
67
68	case '\t-': // decrease basic indentation
69	if (tabStops.length > 0) {	2,116✔
70	const lastStop = tabStops[tabStops.length-1];	514✔
71	tabStops[tabStops.length-1] = lastStop.substring(0, lastStop.length - BASIC_INDENT);	514✔
72	} else {
73	indent = indent.substring(0, indent.length - BASIC_INDENT);	1,602✔
74	}
75	continue;	2,116✔
76
77	case '\t=+': // add a tab stop at the current position
78	tabStops.push(' '.repeat(getColumn()));	1,484✔
79	continue;	1,484✔
80
81	case '\t=-': // remove a previously added tab stop
82	tabStops.pop();	1,484✔
83	continue;	1,484✔
84
85	case '\n-': // remove the last newline
86	if (buffer.endsWith('\n'))	×
87	buffer = buffer.substring(0, buffer.length-1);	×
88	continue;	×
89
90	case '\n':
91	// remove an extra space if we just added it
92	if (buffer.endsWith(' '))	16,288✔
93	buffer = buffer.substring(0, buffer.length-1);	1,234✔
94	buffer += '\n';	16,288✔
95	needsIndent = true;	16,288✔
96	continue;	16,288✔
97	}
98
99	if (/[ \n\t]/.test(String(token)))	103,790!
100	throw new Error(`Invalid control token "${token}"`);	×
101
102	if (needsIndent) {	103,790✔
103	if (tabStops.length > 0)	14,054✔
104	buffer += tabStops[tabStops.length-1];	2,576✔
105	else
106	buffer += indent;	11,478✔
107	needsIndent = false;	14,054✔
108	}
109
110	// convert literals/constants back to their surface representation
111	if (token instanceof ConstantToken) {	103,790✔
112	const constant = token;	5,224✔
113
114	switch (constant.name) {	5,224✔
115	case 'QUOTED_STRING':	5,224!
116	buffer += stringEscape(constant.value);	2,402✔
117	break;	2,402✔
118	case 'NUMBER':
119	buffer += String(constant.value);	1,248✔
120	break;	1,248✔
121	case 'MEASURE': {
122	const measure = constant.value;	274✔
123	buffer += String(measure.value) + measure.unit;	274✔
124	break;	274✔
125	}
126	case 'CURRENCY': {
127	const currency = constant.value;	22✔
128	buffer += String(currency.value) + '$' + currency.unit;	22✔
129	break;	22✔
130	}
131	case 'LOCATION': {
132	const location = constant.value;	80✔
133
134	if (Number.isNaN(location.latitude) && Number.isNaN(location.longitude))	80✔
135	buffer += `new Location(${stringEscape(location.display)})`;	18✔
136	else if (location.display !== null)	62✔
137	buffer += `new Location(${location.latitude}, ${location.longitude}, ${stringEscape(location.display)})`;	16✔
138	else
139	buffer += `new Location(${location.latitude}, ${location.longitude})`;	46✔
140	break;	80✔
141	}
142	case 'DATE': {
143	const date = constant.value;	56✔
144	buffer += `new Date(${stringEscape(date.toISOString())})`;	56✔
145	break;	56✔
146	}
147	case 'TIME': {
148	const time = constant.value;	288✔
149	if (time.second !== 0)	288!
150	buffer += `new Time(${time.hour}, ${time.minute}, ${time.second})`;	×
151	else
152	buffer += `new Time(${time.hour}, ${time.minute})`;	288✔
153	break;	288✔
154	}
155	case 'PICTURE':
156	buffer += simpleEntity(constant, 'tt:picture');	64✔
157	break;	64✔
158	case 'USERNAME':
159	buffer += simpleEntity(constant, 'tt:username');	64✔
160	break;	64✔
161	case 'HASHTAG':
162	buffer += simpleEntity(constant, 'tt:hashtag');	36✔
163	break;	36✔
164	case 'URL':
165	buffer += simpleEntity(constant, 'tt:url');	252✔
166	break;	252✔
167	case 'PHONE_NUMBER':
168	buffer += simpleEntity(constant, 'tt:phone_number');	24✔
169	break;	24✔
170	case 'EMAIL_ADDRESS':
171	buffer += simpleEntity(constant, 'tt:email_address');	8✔
172	break;	8✔
173	case 'PATH_NAME':
174	buffer += simpleEntity(constant, 'tt:path_name');	×
175	break;	×
176	case 'GENERIC_ENTITY': {
177	const entity = constant.value;	406✔
178	if (entity.value === null)	406✔
179	buffer += 'null';	30✔
180	else
181	buffer += stringEscape(entity.value);	376✔
182	buffer += '^^' + entity.type;	406✔
183	if (entity.display !== null)	406✔
184	buffer += '(' + stringEscape(entity.display) + ')';	100✔
185	break;	406✔
186	}
187	}
188
189	continue;	5,224✔
190	}
191
192	// now the actual tokens
193	switch (token) {	98,566✔
194	case ')':	308,494!
195	// eat a space if we're closing an enum and we had a keyword that introduced a space
196	if (/\benum\([a-z]+ $/.test(buffer))	8,962!
197	buffer = buffer.substring(0, buffer.length-1);	×
198	buffer += ')';	8,962✔
199	break;	8,962✔
200
201	case '*':
202	if (buffer.endsWith('[')) // projection	90!
203	buffer += token;	90✔
204	else // multiplication
NEW 205	buffer += (buffer.endsWith(' ') ? '' : ' ') + token + ' ';	×
206	break;	90✔
207
208	// add a space before and after certain operators
209	case ':':
210	case '+':
211	case '-':
212	case '/':
213	case '%':
214	case '**':
215	case '==':
216	case '>=':
217	case '<=':
218	case '>':
219	case '<':
220	case '=~':
221	case '~=':
222	case '\|\|':
223	case '&&':
224	case '::':
225	case '=>':
226	buffer += ' ' + token + ' ';	5,358✔
227	break;	5,358✔
228
229	// add a space after the comma and certain keywords,
230	case ',':
231	case 'abstract':
232	case 'class':
233	case 'const':
234	case 'dataset':
235	case 'enum':
236	case 'if':
237	case 'import':
238	case 'in':
239	case 'for':
240	case 'function':
241	case 'let':
242	case 'list':
243	case 'mixin':
244	case 'monitorable':
245	case 'new':
246	case 'opt':
247	case 'out':
248	case 'req':
249	case 'return':
250	case 'switch':
251	case 'until':
252	case 'when':
253	case 'while':
254	case '$dialogue':
255	case '$policy':
256	buffer += token;	7,762✔
257	if (!buffer.endsWith('enum '))	7,762!
258	buffer += ' ';	7,762✔
259	break;	7,762✔
260
261	// add a space BEFORE and AFTER filter, with, of, and as
262	// this is necessary because they can follow a variable name immediately
263	case 'with':
264	case 'filter':
265	case 'of':
266	case 'as':
267	case 'extends':
268	case 'join':
269	case 'on':
270	if (buffer.endsWith('enum '))	2,506✔
271	buffer += token;	84✔
272	else
273	buffer += ' ' + token + ' ';	2,422✔
274	break;	2,506✔
275
276	// the following keywords DO NOT receive a space: null, true, false, sort
277
278	// other tokens
279	default:
280	buffer += token;	73,888✔
281	}
282	}
283
284	return buffer.trim();	3,416✔
285	}

stanford-oval / thingtalk / 1507

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