rokucommunity / brs / #64

Committed 30 Mar 2024 04:29PM UTC coverage: 90.458% (-0.6%) from 91.032%

Build # #64

Build Type

push

Committed by

Commit Message

Added to CLI: colorization and commans `help`, `clear` and `vars` (#49)

Run Details

1858 of 2206 branches covered (84.22%)

Branch coverage included in aggregate %.

15 of 57 new or added lines in 4 files covered. (26.32%)

2 existing lines in 1 file now uncovered.

5432 of 5853 relevant lines covered (92.81%)

8639.36 hits per line

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

58.16

/src/index.ts

import * as fs from "fs";
import * as readline from "readline";
import chalk from "chalk";

import { promisify } from "util";
const mkdtemp = promisify(fs.mkdtemp);
import decompress from "decompress";
import sanitizeFilename from "sanitize-filename";

import { Lexer } from "./lexer";
import * as PP from "./preprocessor";
import {
    getComponentDefinitionMap,
    ComponentDefinition,
    ComponentScript,
} from "./componentprocessor";
import { Parser } from "./parser";
import { Interpreter, ExecutionOptions, defaultExecutionOptions, colorize } from "./interpreter";
import { Environment, Scope } from "./interpreter/Environment";
import { resetTestData } from "./extensions";
import * as BrsError from "./Error";
import * as LexerParser from "./LexerParser";
import { CoverageCollector } from "./coverage";
import { loadTranslationFiles } from "./stdlib";

import * as _lexer from "./lexer";
export { _lexer as lexer };
import * as BrsTypes from "./brsTypes";
export { BrsTypes as types };
import { PrimitiveKinds, ValueKind, isIterable } from "./brsTypes";
export { PP as preprocessor };
import * as _parser from "./parser";
export { _parser as parser };
import { URL } from "url";
import * as path from "path";
import pSettle from "p-settle";
import os from "os";

let coverageCollector: CoverageCollector | null = null;

/**
 * Executes a BrightScript file by path and writes its output to the streams
 * provided in `options`.
 *
 * @param filename the absolute path to the `.brs` file to be executed
 * @param options configuration for the execution, including the streams to use for `stdout` and
 *                `stderr` and the base directory for path resolution
 *
 * @returns a `Promise` that will be resolve if `filename` is successfully
 *          executed, or be rejected if an error occurs.
 */
export async function execute(filenames: string[], options: Partial<ExecutionOptions>) {
    let { lexerParserFn, interpreter } = await loadFiles(options);
    let mainStatements = await lexerParserFn(filenames);
    return interpreter.exec(mainStatements);
}

async function loadFiles(options: Partial<ExecutionOptions>) {
    const executionOptions = { ...defaultExecutionOptions, ...options };

    let manifest = await PP.getManifest(executionOptions.root);
    let maybeLibraryName = options.isComponentLibrary
        ? manifest.get("sg_component_libs_provided")
        : undefined;
    if (typeof maybeLibraryName === "boolean") {
        throw new Error(
            "Encountered invalid boolean value for manifest key 'sg_component_libs_provided'"
        );
    } else if (options.isComponentLibrary && maybeLibraryName == null) {
        throw new Error(
            "Could not find required manifest key 'sg_component_libs_provided' in component library"
        );
    }
    let componentDefinitions = await getComponentDefinitionMap(
        executionOptions.root,
        executionOptions.componentDirs,
        maybeLibraryName
    );

    let componentLibraries = Array.from(componentDefinitions.values())
        .map((component: ComponentDefinition) => ({
            component,
            libraries: component.children.filter(
                (child) => child.name.toLowerCase() === "componentlibrary"
            ),
        }))
        .filter(({ libraries }) => libraries && libraries.length > 0);

    let knownComponentLibraries = new Map<string, string>();
    let componentLibrariesToLoad: ReturnType<typeof loadFiles>[] = [];
    for (let { component, libraries } of componentLibraries) {
        for (let cl of libraries) {
            let uri = cl.fields.uri;
            if (!uri) {
                continue;
            }
            if (uri.startsWith("http://") || uri.startsWith("https://")) {
                executionOptions.stderr.write(
                    `WARNING: Only pkg:/-local component libraries are supported; ignoring '${uri}'\n`
                );
                continue;
            }
            let posixRoot = executionOptions.root.replace(/[\/\\]+/g, path.posix.sep);
            let posixPath = component.xmlPath.replace(/[\/\\]+/g, path.posix.sep);
            if (process.platform === "win32") {
                posixRoot = posixRoot.replace(/^[a-zA-Z]:/, "");
                posixPath = posixPath.replace(/^[a-zA-Z]:/, "");
            }

            let packageUri = new URL(
                uri,
                `pkg:/${path.posix.relative(posixRoot, posixPath)}`
            ).toString();
            if (knownComponentLibraries.has(packageUri)) {
                continue;
            }

            let sanitizedUri = sanitizeFilename(packageUri);
            let tempdir = await mkdtemp(path.join(os.tmpdir(), `brs-${sanitizedUri}`), "utf8");
            knownComponentLibraries.set(packageUri, tempdir);

            let zipFileOnDisk = path.join(executionOptions.root, new URL(uri).pathname);

            componentLibrariesToLoad.push(
                decompress(zipFileOnDisk, tempdir).then(() =>
                    loadFiles({
                        ...options,
                        root: tempdir,
                        componentDirs: [],
                        isComponentLibrary: true,
                    })
                )
            );
        }
    }

    componentDefinitions.forEach((component: ComponentDefinition) => {
        if (component.scripts.length < 1) return;
        try {
            component.scripts = component.scripts.map((script: ComponentScript) => {
                script.uri = path.join(executionOptions.root, new URL(script.uri).pathname);
                return script;
            });
        } catch (error) {
            throw new Error(
                `Encountered an error when parsing component ${component.name}: ${error}`
            );
        }
    });

    let lexerParserFn = LexerParser.getLexerParserFn(manifest, options);
    const interpreter = await Interpreter.withSubEnvsFromComponents(
        componentDefinitions,
        lexerParserFn,
        executionOptions
    );
    if (!interpreter) {
        throw new Error("Unable to build interpreter.");
    }

    // Store manifest as a property on the Interpreter for further reusing
    interpreter.manifest = manifest;

    let componentLibraryInterpreters = (await pSettle(componentLibrariesToLoad))
        .filter((result) => result.isFulfilled)
        .map((result) => result.value!.interpreter);
    interpreter.mergeNodeDefinitionsWith(componentLibraryInterpreters);

    await loadTranslationFiles(interpreter, executionOptions.root);

    if (executionOptions.generateCoverage) {
        coverageCollector = new CoverageCollector(executionOptions.root, lexerParserFn);
        await coverageCollector.crawlBrsFiles();
        interpreter.setCoverageCollector(coverageCollector);
    }
    return { lexerParserFn, interpreter };
}

/**
 * Returns a summary of the code coverage.
 */
export function getCoverageResults() {
    if (!coverageCollector) return;
    return coverageCollector.getCoverage();
}

/**
 * A synchronous version of the lexer-parser flow.
 *
 * @param filename the paths to BrightScript files to lex and parse synchronously
 * @param options configuration for the execution, including the streams to use for `stdout` and
 *                `stderr` and the base directory for path resolution
 *
 * @returns the AST produced from lexing and parsing the provided files
 */
export function lexParseSync(filenames: string[], options: Partial<ExecutionOptions>) {
    const executionOptions = { ...defaultExecutionOptions, ...options };

    let manifest = PP.getManifestSync(executionOptions.root);

    return filenames
        .map((filename) => {
            let lexer = new Lexer();
            let preprocessor = new PP.Preprocessor();
            let parser = new Parser();
            [lexer, preprocessor, parser].forEach((emitter) =>
                emitter.onError(BrsError.getLoggerUsing(executionOptions.stderr))
            );

            let contents = fs.readFileSync(filename, "utf8");
            let scanResults = lexer.scan(contents, filename);
            let preprocessorResults = preprocessor.preprocess(scanResults.tokens, manifest);
            let parseResults = parser.parse(preprocessorResults.processedTokens);

            if (parseResults.errors.length > 0) {
                throw "Error occurred parsing";
            }

            return parseResults.statements;
        })
        .reduce((allStatements, statements) => [...allStatements, ...statements], []);
}

export type ExecuteWithScope = (filenames: string[], args: BrsTypes.BrsType[]) => BrsTypes.BrsType;
/**
 * Runs a set of files to create an execution scope, and generates an execution function that runs in that scope.
 *
 * @param filenamesForScope List of filenames to put into the execution scope
 * @param options Execution options
 *
 * @returns A function to execute files using the created scope.
 */
export async function createExecuteWithScope(
    filenamesForScope: string[],
    options: Partial<ExecutionOptions>
): Promise<ExecuteWithScope> {
    let { lexerParserFn, interpreter } = await loadFiles(options);
    let mainStatements = await lexerParserFn(filenamesForScope);
    interpreter.exec(mainStatements);
    // Clear any errors that accumulated, so that we can isolate errors from future calls to the execute function.
    interpreter.errors = [];

    return (filenames: string[], args: BrsTypes.BrsType[]) => {
        // Reset any mocks so that subsequent executions don't interfere with each other.
        interpreter.environment.resetMocks();
        resetTestData();

        let ast = lexParseSync(filenames, interpreter.options);
        let execErrors: BrsError.BrsError[] = [];
        let returnValue = interpreter.inSubEnv((subInterpreter) => {
            let value = subInterpreter.exec(ast, ...args)[0] || BrsTypes.BrsInvalid.Instance;
            execErrors = subInterpreter.errors;
            subInterpreter.errors = [];
            return value;
        });

        // Re-throw any errors the interpreter encounters. We can't throw them directly from the `inSubEnv` call,
        // because they get caught by upstream handlers.
        if (execErrors.length) {
            throw execErrors;
        }

        return returnValue;
    };
}

/**
 * Launches an interactive read-execute-print loop, which reads input from
 * `stdin` and executes it.
 *
 * **NOTE:** Currently limited to single-line inputs :(
 */
export function repl() {
    const replInterpreter = new Interpreter();
    replInterpreter.onError(BrsError.getLoggerUsing(process.stderr));

    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
    });
    rl.setPrompt(`${chalk.magenta("brs")}> `);
    rl.on("line", (line) => {
        const cmd = line.trim().toLowerCase();
        if (["quit", "exit", "q"].includes(cmd)) {
            process.exit();
        } else if (["cls", "clear"].includes(cmd)) {
            process.stdout.write("\x1Bc");
            rl.prompt();
            return;
        } else if (["help", "hint"].includes(cmd)) {
            printHelp();
            rl.prompt();
            return;
        } else if (["vars", "var"].includes(cmd)) {
            printLocalVariables(replInterpreter.environment);
            rl.prompt();
            return;
        }
        let results = run(line, defaultExecutionOptions, replInterpreter);
        if (results) {
            results.map((result) => {
                if (result !== BrsTypes.BrsInvalid.Instance) {
                    console.log(colorize(result.toString()));
                }
            });
        }
        rl.prompt();
    });

    console.log(colorize("type `help` to see the list of valid REPL commands.\r\n"));
    rl.prompt();
}

/**
 * Runs an arbitrary string of BrightScript code.
 * @param contents the BrightScript code to lex, parse, and interpret.
 * @param options the streams to use for `stdout` and `stderr`. Mostly used for
 *                testing.
 * @param interpreter an interpreter to use when executing `contents`. Required
 *                    for `repl` to have persistent state between user inputs.
 * @returns an array of statement execution results, indicating why each
 *          statement exited and what its return value was, or `undefined` if
 *          `interpreter` threw an Error.
 */
function run(
    contents: string,
    options: ExecutionOptions = defaultExecutionOptions,
    interpreter: Interpreter
) {
    const lexer = new Lexer();
    const parser = new Parser();
    const logErrorFn = BrsError.getLoggerUsing(options.stderr);

    lexer.onError(logErrorFn);
    parser.onError(logErrorFn);

    const scanResults = lexer.scan(contents, "REPL");
    if (scanResults.errors.length > 0) {
        return;
    }

    const parseResults = parser.parse(scanResults.tokens);
    if (parseResults.errors.length > 0) {
        return;
    }

    if (parseResults.statements.length === 0) {
        return;
    }

    try {
        return interpreter.exec(parseResults.statements);
    } catch (e) {
        //options.stderr.write(e.message);
        return;
    }
}

/**
 * Display the help message on the console.
 */
function printHelp() {
    let helpMsg = "\r\n";
    helpMsg += "REPL Command List:\r\n";
    helpMsg += "   print|?         Print variable value or expression\r\n";
    helpMsg += "   var|vars        Display variables and their types/values\r\n";
    helpMsg += "   help|hint       Show this REPL command list\r\n";
    helpMsg += "   clear|cls       Clear terminal screen\r\n";
    helpMsg += "   exit|quit|q     Terminate REPL session\r\n\r\n";
    helpMsg += "   Type any valid BrightScript expression for a live compile and run.\r\n";
    console.log(chalk.cyanBright(helpMsg));
}

/**
 * Display the local variables on the console.
 * @param environment an object with the Interpreter Environment data
 */
function printLocalVariables(environment: Environment) {
    let debugMsg = "\r\nLocal variables:\r\n";
    debugMsg += `${"m".padEnd(16)} roAssociativeArray count:${
        environment.getM().getElements().length
    }\r\n`;
    let fnc = environment.getList(Scope.Function);
    fnc.forEach((value, key) => {
        if (PrimitiveKinds.has(value.kind)) {
            debugMsg += `${key.padEnd(16)} ${ValueKind.toString(
                value.kind
            )} val:${value.toString()}\r\n`;
        } else if (isIterable(value)) {
            debugMsg += `${key.padEnd(16)} ${value.getComponentName()} count:${
                value.getElements().length
            }\r\n`;
        } else if (value.kind === ValueKind.Object) {
            debugMsg += `${key.padEnd(17)}${value.getComponentName()}\r\n`;
        } else {
            debugMsg += `${key.padEnd(17)}${value.toString()}\r\n`;
        }
    });
    console.log(chalk.cyanBright(debugMsg));
}

1	import * as fs from "fs";	132✔
2	import * as readline from "readline";	132✔
3	import chalk from "chalk";	132✔
4
5	import { promisify } from "util";	132✔
6	const mkdtemp = promisify(fs.mkdtemp);	132✔
7	import decompress from "decompress";	132✔
8	import sanitizeFilename from "sanitize-filename";	132✔
9
10	import { Lexer } from "./lexer";	132✔
11	import * as PP from "./preprocessor";	132✔
12	import {	132✔
13	getComponentDefinitionMap,
14	ComponentDefinition,
15	ComponentScript,
16	} from "./componentprocessor";
17	import { Parser } from "./parser";	132✔
18	import { Interpreter, ExecutionOptions, defaultExecutionOptions, colorize } from "./interpreter";	132✔
19	import { Environment, Scope } from "./interpreter/Environment";	132✔
20	import { resetTestData } from "./extensions";	132✔
21	import * as BrsError from "./Error";	132✔
22	import * as LexerParser from "./LexerParser";	132✔
23	import { CoverageCollector } from "./coverage";	132✔
24	import { loadTranslationFiles } from "./stdlib";	132✔
25
26	import * as _lexer from "./lexer";	132✔
27	export { _lexer as lexer };	132✔
28	import * as BrsTypes from "./brsTypes";	132✔
29	export { BrsTypes as types };	132✔
30	import { PrimitiveKinds, ValueKind, isIterable } from "./brsTypes";	132✔
31	export { PP as preprocessor };	132✔
32	import * as _parser from "./parser";	132✔
33	export { _parser as parser };	132✔
34	import { URL } from "url";	132✔
35	import * as path from "path";	132✔
36	import pSettle from "p-settle";	132✔
37	import os from "os";	132✔
38
39	let coverageCollector: CoverageCollector \| null = null;	132✔
40
41	/**
42	* Executes a BrightScript file by path and writes its output to the streams
43	* provided in `options`.
44	*
45	* @param filename the absolute path to the `.brs` file to be executed
46	* @param options configuration for the execution, including the streams to use for `stdout` and
47	* `stderr` and the base directory for path resolution
48	*
49	* @returns a `Promise` that will be resolve if `filename` is successfully
50	* executed, or be rejected if an error occurs.
51	*/
52	export async function execute(filenames: string[], options: Partial<ExecutionOptions>) {	132✔
53	let { lexerParserFn, interpreter } = await loadFiles(options);	102✔
54	let mainStatements = await lexerParserFn(filenames);	102✔
55	return interpreter.exec(mainStatements);	101✔
56	}
57
58	async function loadFiles(options: Partial<ExecutionOptions>) {
59	const executionOptions = { ...defaultExecutionOptions, ...options };	107✔
60
61	let manifest = await PP.getManifest(executionOptions.root);	107✔
62	let maybeLibraryName = options.isComponentLibrary	107✔
63	? manifest.get("sg_component_libs_provided")
64	: undefined;
65	if (typeof maybeLibraryName === "boolean") {	107!
66	throw new Error(	×
67	"Encountered invalid boolean value for manifest key 'sg_component_libs_provided'"
68	);
69	} else if (options.isComponentLibrary && maybeLibraryName == null) {	107!
70	throw new Error(	×
71	"Could not find required manifest key 'sg_component_libs_provided' in component library"
72	);
73	}
74	let componentDefinitions = await getComponentDefinitionMap(	107✔
75	executionOptions.root,
76	executionOptions.componentDirs,
77	maybeLibraryName
78	);
79
80	let componentLibraries = Array.from(componentDefinitions.values())	107✔
81	.map((component: ComponentDefinition) => ({	1,695✔
82	component,
83	libraries: component.children.filter(
84	(child) => child.name.toLowerCase() === "componentlibrary"	899✔
85	),
86	}))
87	.filter(({ libraries }) => libraries && libraries.length > 0);	1,695✔
88
89	let knownComponentLibraries = new Map<string, string>();	107✔
90	let componentLibrariesToLoad: ReturnType<typeof loadFiles>[] = [];	107✔
91	for (let { component, libraries } of componentLibraries) {	107✔
92	for (let cl of libraries) {	1✔
93	let uri = cl.fields.uri;	2✔
94	if (!uri) {	2!
95	continue;	×
96	}
97	if (uri.startsWith("http://") \|\| uri.startsWith("https://")) {	2✔
98	executionOptions.stderr.write(	1✔
99	`WARNING: Only pkg:/-local component libraries are supported; ignoring '${uri}'\n`
100	);
101	continue;	1✔
102	}
103	let posixRoot = executionOptions.root.replace(/[\/\\]+/g, path.posix.sep);	1✔
104	let posixPath = component.xmlPath.replace(/[\/\\]+/g, path.posix.sep);	1✔
105	if (process.platform === "win32") {	1!
106	posixRoot = posixRoot.replace(/^[a-zA-Z]:/, "");	×
107	posixPath = posixPath.replace(/^[a-zA-Z]:/, "");	×
108	}
109
110	let packageUri = new URL(	1✔
111	uri,
112	`pkg:/${path.posix.relative(posixRoot, posixPath)}`
113	).toString();
114	if (knownComponentLibraries.has(packageUri)) {	1!
115	continue;	×
116	}
117
118	let sanitizedUri = sanitizeFilename(packageUri);	1✔
119	let tempdir = await mkdtemp(path.join(os.tmpdir(), `brs-${sanitizedUri}`), "utf8");	1✔
120	knownComponentLibraries.set(packageUri, tempdir);	1✔
121
122	let zipFileOnDisk = path.join(executionOptions.root, new URL(uri).pathname);	1✔
123
124	componentLibrariesToLoad.push(	1✔
125	decompress(zipFileOnDisk, tempdir).then(() =>
126	loadFiles({	1✔
127	...options,
128	root: tempdir,
129	componentDirs: [],
130	isComponentLibrary: true,
131	})
132	)
133	);
134	}
135	}
136
137	componentDefinitions.forEach((component: ComponentDefinition) => {	107✔
138	if (component.scripts.length < 1) return;	1,695✔
139	try {	1,247✔
140	component.scripts = component.scripts.map((script: ComponentScript) => {	1,247✔
141	script.uri = path.join(executionOptions.root, new URL(script.uri).pathname);	1,641✔
142	return script;	1,641✔
143	});
144	} catch (error) {
145	throw new Error(	×
146	`Encountered an error when parsing component ${component.name}: ${error}`
147	);
148	}
149	});
150
151	let lexerParserFn = LexerParser.getLexerParserFn(manifest, options);	107✔
152	const interpreter = await Interpreter.withSubEnvsFromComponents(	107✔
153	componentDefinitions,
154	lexerParserFn,
155	executionOptions
156	);
157	if (!interpreter) {	107!
158	throw new Error("Unable to build interpreter.");	×
159	}
160
161	// Store manifest as a property on the Interpreter for further reusing
162	interpreter.manifest = manifest;	107✔
163
164	let componentLibraryInterpreters = (await pSettle(componentLibrariesToLoad))	107✔
165	.filter((result) => result.isFulfilled)	1✔
166	.map((result) => result.value!.interpreter);	1✔
167	interpreter.mergeNodeDefinitionsWith(componentLibraryInterpreters);	107✔
168
169	await loadTranslationFiles(interpreter, executionOptions.root);	107✔
170
171	if (executionOptions.generateCoverage) {	107✔
172	coverageCollector = new CoverageCollector(executionOptions.root, lexerParserFn);	1✔
173	await coverageCollector.crawlBrsFiles();	1✔
174	interpreter.setCoverageCollector(coverageCollector);	1✔
175	}
176	return { lexerParserFn, interpreter };	107✔
177	}
178
179	/**
180	* Returns a summary of the code coverage.
181	*/
182	export function getCoverageResults() {	132✔
183	if (!coverageCollector) return;	1!
184	return coverageCollector.getCoverage();	1✔
185	}
186
187	/**
188	* A synchronous version of the lexer-parser flow.
189	*
190	* @param filename the paths to BrightScript files to lex and parse synchronously
191	* @param options configuration for the execution, including the streams to use for `stdout` and
192	* `stderr` and the base directory for path resolution
193	*
194	* @returns the AST produced from lexing and parsing the provided files
195	*/
196	export function lexParseSync(filenames: string[], options: Partial<ExecutionOptions>) {	132✔
197	const executionOptions = { ...defaultExecutionOptions, ...options };	23✔
198
199	let manifest = PP.getManifestSync(executionOptions.root);	23✔
200
201	return filenames	23✔
202	.map((filename) => {
203	let lexer = new Lexer();	22✔
204	let preprocessor = new PP.Preprocessor();	22✔
205	let parser = new Parser();	22✔
206	[lexer, preprocessor, parser].forEach((emitter) =>	22✔
207	emitter.onError(BrsError.getLoggerUsing(executionOptions.stderr))	66✔
208	);
209
210	let contents = fs.readFileSync(filename, "utf8");	22✔
211	let scanResults = lexer.scan(contents, filename);	22✔
212	let preprocessorResults = preprocessor.preprocess(scanResults.tokens, manifest);	22✔
213	let parseResults = parser.parse(preprocessorResults.processedTokens);	22✔
214
215	if (parseResults.errors.length > 0) {	22✔
216	throw "Error occurred parsing";	4✔
217	}
218
219	return parseResults.statements;	18✔
220	})
221	.reduce((allStatements, statements) => [...allStatements, ...statements], []);	18✔
222	}
223
224	export type ExecuteWithScope = (filenames: string[], args: BrsTypes.BrsType[]) => BrsTypes.BrsType;
225	/**
226	* Runs a set of files to create an execution scope, and generates an execution function that runs in that scope.
227	*
228	* @param filenamesForScope List of filenames to put into the execution scope
229	* @param options Execution options
230	*
231	* @returns A function to execute files using the created scope.
232	*/
233	export async function createExecuteWithScope(	132✔
234	filenamesForScope: string[],
235	options: Partial<ExecutionOptions>
236	): Promise<ExecuteWithScope> {
237	let { lexerParserFn, interpreter } = await loadFiles(options);	4✔
238	let mainStatements = await lexerParserFn(filenamesForScope);	4✔
239	interpreter.exec(mainStatements);	4✔
240	// Clear any errors that accumulated, so that we can isolate errors from future calls to the execute function.
241	interpreter.errors = [];	4✔
242
243	return (filenames: string[], args: BrsTypes.BrsType[]) => {	4✔
244	// Reset any mocks so that subsequent executions don't interfere with each other.
245	interpreter.environment.resetMocks();	7✔
246	resetTestData();	7✔
247
248	let ast = lexParseSync(filenames, interpreter.options);	7✔
249	let execErrors: BrsError.BrsError[] = [];	7✔
250	let returnValue = interpreter.inSubEnv((subInterpreter) => {	7✔
251	let value = subInterpreter.exec(ast, ...args)[0] \|\| BrsTypes.BrsInvalid.Instance;	7!
252	execErrors = subInterpreter.errors;	7✔
253	subInterpreter.errors = [];	7✔
254	return value;	7✔
255	});
256
257	// Re-throw any errors the interpreter encounters. We can't throw them directly from the `inSubEnv` call,
258	// because they get caught by upstream handlers.
259	if (execErrors.length) {	7✔
260	throw execErrors;	2✔
261	}
262
263	return returnValue;	5✔
264	};
265	}
266
267	/**
268	* Launches an interactive read-execute-print loop, which reads input from
269	* `stdin` and executes it.
270	*
271	* NOTE: Currently limited to single-line inputs :(
272	*/
273	export function repl() {	132✔
274	const replInterpreter = new Interpreter();	×
275	replInterpreter.onError(BrsError.getLoggerUsing(process.stderr));	×
276
277	const rl = readline.createInterface({	×
278	input: process.stdin,
279	output: process.stdout,
280	});
NEW 281	rl.setPrompt(`${chalk.magenta("brs")}> `);	×
282	rl.on("line", (line) => {	×
NEW 283	const cmd = line.trim().toLowerCase();	×
NEW 284	if (["quit", "exit", "q"].includes(cmd)) {	×
UNCOV 285	process.exit();	×
NEW 286	} else if (["cls", "clear"].includes(cmd)) {	×
NEW 287	process.stdout.write("\x1Bc");	×
NEW 288	rl.prompt();	×
NEW 289	return;	×
NEW 290	} else if (["help", "hint"].includes(cmd)) {	×
NEW 291	printHelp();	×
NEW 292	rl.prompt();	×
NEW 293	return;	×
NEW 294	} else if (["vars", "var"].includes(cmd)) {	×
NEW 295	printLocalVariables(replInterpreter.environment);	×
NEW 296	rl.prompt();	×
NEW 297	return;	×
298	}
299	let results = run(line, defaultExecutionOptions, replInterpreter);	×
300	if (results) {	×
301	results.map((result) => {	×
302	if (result !== BrsTypes.BrsInvalid.Instance) {	×
NEW 303	console.log(colorize(result.toString()));	×
304	}
305	});
306	}
307	rl.prompt();	×
308	});
309
NEW 310	console.log(colorize("type `help` to see the list of valid REPL commands.\r\n"));	×
UNCOV 311	rl.prompt();	×
312	}
313
314	/**
315	* Runs an arbitrary string of BrightScript code.
316	* @param contents the BrightScript code to lex, parse, and interpret.
317	* @param options the streams to use for `stdout` and `stderr`. Mostly used for
318	* testing.
319	* @param interpreter an interpreter to use when executing `contents`. Required
320	* for `repl` to have persistent state between user inputs.
321	* @returns an array of statement execution results, indicating why each
322	* statement exited and what its return value was, or `undefined` if
323	* `interpreter` threw an Error.
324	*/
325	function run(
326	contents: string,
327	options: ExecutionOptions = defaultExecutionOptions,	×
328	interpreter: Interpreter
329	) {
330	const lexer = new Lexer();	×
331	const parser = new Parser();	×
332	const logErrorFn = BrsError.getLoggerUsing(options.stderr);	×
333
334	lexer.onError(logErrorFn);	×
335	parser.onError(logErrorFn);	×
336
337	const scanResults = lexer.scan(contents, "REPL");	×
338	if (scanResults.errors.length > 0) {	×
339	return;	×
340	}
341
342	const parseResults = parser.parse(scanResults.tokens);	×
343	if (parseResults.errors.length > 0) {	×
344	return;	×
345	}
346
347	if (parseResults.statements.length === 0) {	×
348	return;	×
349	}
350
351	try {	×
352	return interpreter.exec(parseResults.statements);	×
353	} catch (e) {
354	//options.stderr.write(e.message);
355	return;	×
356	}
357	}
358
359	/**
360	* Display the help message on the console.
361	*/
362	function printHelp() {
NEW 363	let helpMsg = "\r\n";	×
NEW 364	helpMsg += "REPL Command List:\r\n";	×
NEW 365	helpMsg += " print\|? Print variable value or expression\r\n";	×
NEW 366	helpMsg += " var\|vars Display variables and their types/values\r\n";	×
NEW 367	helpMsg += " help\|hint Show this REPL command list\r\n";	×
NEW 368	helpMsg += " clear\|cls Clear terminal screen\r\n";	×
NEW 369	helpMsg += " exit\|quit\|q Terminate REPL session\r\n\r\n";	×
NEW 370	helpMsg += " Type any valid BrightScript expression for a live compile and run.\r\n";	×
NEW 371	console.log(chalk.cyanBright(helpMsg));	×
372	}
373
374	/**
375	* Display the local variables on the console.
376	* @param environment an object with the Interpreter Environment data
377	*/
378	function printLocalVariables(environment: Environment) {
NEW 379	let debugMsg = "\r\nLocal variables:\r\n";	×
NEW 380	debugMsg += `${"m".padEnd(16)} roAssociativeArray count:${	×
381	environment.getM().getElements().length
382	}\r\n`;
NEW 383	let fnc = environment.getList(Scope.Function);	×
NEW 384	fnc.forEach((value, key) => {	×
NEW 385	if (PrimitiveKinds.has(value.kind)) {	×
NEW 386	debugMsg += `${key.padEnd(16)} ${ValueKind.toString(	×
387	value.kind
388	)} val:${value.toString()}\r\n`;
NEW 389	} else if (isIterable(value)) {	×
NEW 390	debugMsg += `${key.padEnd(16)} ${value.getComponentName()} count:${	×
391	value.getElements().length
392	}\r\n`;
NEW 393	} else if (value.kind === ValueKind.Object) {	×
NEW 394	debugMsg += `${key.padEnd(17)}${value.getComponentName()}\r\n`;	×
395	} else {
NEW 396	debugMsg += `${key.padEnd(17)}${value.toString()}\r\n`;	×
397	}
398	});
NEW 399	console.log(chalk.cyanBright(debugMsg));	×
400	}

rokucommunity / brs / #64

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