1584

pending completion

Build # 1584

Build Type

push

travis-ci-com

Committed by

gcampax

Commit Message

v2.1.0-alpha.11

Run Details

4663 of 6508 branches covered (71.65%)

Branch coverage included in aggregate %.

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

25 existing lines in 2 files now uncovered.

10532 of 13013 relevant lines covered (80.93%)

50330.59 hits per line

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

88.89

/lib/runtime/exec_environment.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 * as Ast from '../ast';
import type * as builtin from './values';

export type CompiledFilterHint =
    // direct comparison
    [string, string, unknown]
    // unary operator
    | [string, string, string, unknown]
    // binary operator
    | [string, string, unknown, string, unknown];

export interface CompiledQueryHints {
    filter ?: CompiledFilterHint[];
    sort ?: [string, 'asc' | 'desc'];
    projection ?: string[];
    limit ?: number;
}

export interface StreamValue {
    [key : string] : unknown;
    __timestamp : number;
}

export type CompiledStatement = (env : ExecEnvironment) => Promise<void>;
export class CompiledProgram {
    hasTrigger : boolean;
    states : number;
    command : CompiledStatement|null;
    rules : CompiledStatement[];

    constructor(states : number,
                command : CompiledStatement|null,
                rules : CompiledStatement[]) {
        this.hasTrigger = rules.length > 0;

        this.states = states;
        this.command = command;
        this.rules = rules;
    }
}

export abstract class ExecEnvironment {
    // this is accessed from compiled ThingTalk code
    _scope : { [key : string] : any };

    private _procedureFrameCounter : number;
    private _procedureFrame : number;
    private _procedureStack : number[];

    constructor() {
        this._scope = {};

        this._procedureFrameCounter = 0;
        this._procedureFrame = 0;
        this._procedureStack = [];
    }

    /* istanbul ignore next */
    get program_id() : builtin.Entity {
        throw new Error('Must be overridden');
    }

    /* istanbul ignore next */
    get locale() : string {
        throw new Error('Must be overridden');
    }

    /* istanbul ignore next */
    get timezone() : string {
        throw new Error('Must be overridden');
    }

    /**
     * Returns a unique id of the current stack frame.
     *
     * The ID is incremented for every procedure call.
     */
    get procedureFrame() : number {
        return this._procedureFrame;
    }

    enterProcedure(procid : number, procname : string) : void {
        // save the calling frame ID on the stack
        this._procedureStack.push(this._procedureFrame);

        // make a fresh ID for the new call
        this._procedureFrameCounter++;
        this._procedureFrame = this._procedureFrameCounter;
    }
    exitProcedure(procid : number, procname : string) : void {
        // check that enter & exit are correctly paired
        assert(this._procedureStack.length > 0);

        // restore the frame ID of the caller from the stack
        this._procedureFrame = this._procedureStack.pop() as number;
    }

    /* istanbul ignore next */
    invokeMonitor(kind : string,
                  attrs : Record<string, string>,
                  fname : string,
                  params : Record<string, unknown>,
                  hints : CompiledQueryHints) : AsyncIterator<[string, StreamValue]> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    invokeTimer(base : Date,
                interval : number,
                frequency : number) : AsyncIterator<StreamValue> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    invokeAtTimer(timeArray : builtin.Time[],
                  expiration_date ?: Date) : AsyncIterator<StreamValue> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    invokeOnTimer(dateArray : Date[]) {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    invokeQuery(kind : string,
                attrs : Record<string, string>,
                fname : string,
                params : Record<string, unknown>,
                hints : CompiledQueryHints) : AsyncIterable<[string, Record<string, unknown>]> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    invokeDBQuery(kind : string,
                  attrs : Record<string, string>,
                  query : Ast.Program) : AsyncIterable<[string, Record<string, unknown>]> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    invokeAction(kind : string,
                 attrs : Record<string, string>,
                 fname : string,
                 params : Record<string, unknown>) : AsyncIterable<[string, Record<string, unknown>]> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    clearGetCache() : void {
        throw new Error('Must be overridden');
    }

    /* istanbul ignore next */
    sendEndOfFlow(principal : string, flow : number) : Promise<void> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    output(outputType : string, output : Record<string, unknown>) : Promise<void> {
        throw new Error('Must be overridden');
    }

    /* istanbul ignore next */
    readState(stateId : number) : Promise<unknown> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    writeState(stateId : number, value : unknown) : Promise<void> {
        throw new Error('Must be overridden');
    }
    /* istanbul ignore next */
    reportError(message : string, err : Error) : Promise<void> {
        throw new Error('Must be overridden');
    }

    formatEvent(outputType : string, output : Record<string, unknown>, hint : string) : Promise<string> {
        throw new Error('Must be overridden');
    }
}

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
23	import * as Ast from '../ast';
24	import type * as builtin from './values';
25
26	export type CompiledFilterHint =
27	// direct comparison
28	[string, string, unknown]
29	// unary operator
30	\| [string, string, string, unknown]
31	// binary operator
32	\| [string, string, unknown, string, unknown];
33
34	export interface CompiledQueryHints {
35	filter ?: CompiledFilterHint[];
36	sort ?: [string, 'asc' \| 'desc'];
37	projection ?: string[];
38	limit ?: number;
39	}
40
41	export interface StreamValue {
42	[key : string] : unknown;
43	__timestamp : number;
44	}
45
46	export type CompiledStatement = (env : ExecEnvironment) => Promise<void>;
47	export class CompiledProgram {	2✔
48	hasTrigger : boolean;
49	states : number;
50	command : CompiledStatement\|null;
51	rules : CompiledStatement[];
52
53	constructor(states : number,
54	command : CompiledStatement\|null,
55	rules : CompiledStatement[]) {
56	this.hasTrigger = rules.length > 0;	362✔
57
58	this.states = states;	362✔
59	this.command = command;	362✔
60	this.rules = rules;	362✔
61	}
62	}
63
64	export abstract class ExecEnvironment {	2✔
65	// this is accessed from compiled ThingTalk code
66	_scope : { [key : string] : any };
67
68	private _procedureFrameCounter : number;
69	private _procedureFrame : number;
70	private _procedureStack : number[];
71
72	constructor() {
73	this._scope = {};	120✔
74
75	this._procedureFrameCounter = 0;	120✔
76	this._procedureFrame = 0;	120✔
77	this._procedureStack = [];	120✔
78	}
79
80	/* istanbul ignore next */
81	get program_id() : builtin.Entity {
82	throw new Error('Must be overridden');
83	}
84
85	/* istanbul ignore next */
86	get locale() : string {
87	throw new Error('Must be overridden');
88	}
89
90	/* istanbul ignore next */
91	get timezone() : string {
92	throw new Error('Must be overridden');
93	}
94
95	/**
96	* Returns a unique id of the current stack frame.
97	*
98	* The ID is incremented for every procedure call.
99	*/
100	get procedureFrame() : number {
UNCOV 101	return this._procedureFrame;	×
102	}
103
104	enterProcedure(procid : number, procname : string) : void {
105	// save the calling frame ID on the stack
106	this._procedureStack.push(this._procedureFrame);	128✔
107
108	// make a fresh ID for the new call
109	this._procedureFrameCounter++;	128✔
110	this._procedureFrame = this._procedureFrameCounter;	128✔
111	}
112	exitProcedure(procid : number, procname : string) : void {
113	// check that enter & exit are correctly paired
114	assert(this._procedureStack.length > 0);	128✔
115
116	// restore the frame ID of the caller from the stack
117	this._procedureFrame = this._procedureStack.pop() as number;	128✔
118	}
119
120	/* istanbul ignore next */
121	invokeMonitor(kind : string,
122	attrs : Record<string, string>,
123	fname : string,
124	params : Record<string, unknown>,
125	hints : CompiledQueryHints) : AsyncIterator<[string, StreamValue]> {
126	throw new Error('Must be overridden');
127	}
128	/* istanbul ignore next */
129	invokeTimer(base : Date,
130	interval : number,
131	frequency : number) : AsyncIterator<StreamValue> {
132	throw new Error('Must be overridden');
133	}
134	/* istanbul ignore next */
135	invokeAtTimer(timeArray : builtin.Time[],
136	expiration_date ?: Date) : AsyncIterator<StreamValue> {
137	throw new Error('Must be overridden');
138	}
139	/* istanbul ignore next */
140	invokeOnTimer(dateArray : Date[]) {
141	throw new Error('Must be overridden');
142	}
143	/* istanbul ignore next */
144	invokeQuery(kind : string,
145	attrs : Record<string, string>,
146	fname : string,
147	params : Record<string, unknown>,
148	hints : CompiledQueryHints) : AsyncIterable<[string, Record<string, unknown>]> {
149	throw new Error('Must be overridden');
150	}
151	/* istanbul ignore next */
152	invokeDBQuery(kind : string,
153	attrs : Record<string, string>,
154	query : Ast.Program) : AsyncIterable<[string, Record<string, unknown>]> {
155	throw new Error('Must be overridden');
156	}
157	/* istanbul ignore next */
158	invokeAction(kind : string,
159	attrs : Record<string, string>,
160	fname : string,
161	params : Record<string, unknown>) : AsyncIterable<[string, Record<string, unknown>]> {
162	throw new Error('Must be overridden');
163	}
164	/* istanbul ignore next */
165	clearGetCache() : void {
166	throw new Error('Must be overridden');
167	}
168
169	/* istanbul ignore next */
170	sendEndOfFlow(principal : string, flow : number) : Promise<void> {
171	throw new Error('Must be overridden');
172	}
173	/* istanbul ignore next */
174	output(outputType : string, output : Record<string, unknown>) : Promise<void> {
175	throw new Error('Must be overridden');
176	}
177
178	/* istanbul ignore next */
179	readState(stateId : number) : Promise<unknown> {
180	throw new Error('Must be overridden');
181	}
182	/* istanbul ignore next */
183	writeState(stateId : number, value : unknown) : Promise<void> {
184	throw new Error('Must be overridden');
185	}
186	/* istanbul ignore next */
187	reportError(message : string, err : Error) : Promise<void> {
188	throw new Error('Must be overridden');
189	}
190
191	formatEvent(outputType : string, output : Record<string, unknown>, hint : string) : Promise<string> {
UNCOV 192	throw new Error('Must be overridden');	×
193	}
194	}

stanford-oval / thingtalk / 1584

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