1362

pending completion

Build # 1362

Build Type

push

travis-ci-com

Committed by

gcampax

Commit Message

v2.0.0-beta.1

Run Details

4439 of 6220 branches covered (71.37%)

Branch coverage included in aggregate %.

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

10 existing lines in 2 files now uncovered.

10172 of 12590 relevant lines covered (80.79%)

47749.33 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 = [string, 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');
    }

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

stanford-oval / thingtalk / 1362

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