26235216720

Committed 21 May 2026 03:18PM UTC coverage: 56.569% (+1.1%) from 55.501%

Build # 26235216720

Build Type

Pull #790

github

Committed by

web-flow

Commit Message

Merge 73903c9d3 into b9f6aae1a

Pull Request Pull Request #790: Add filter dropdown to the Devices view

Coverage Stats

2291 of 4457 branches covered (51.4%)

Branch coverage included in aggregate %.

62 of 65 new or added lines in 3 files covered. (95.38%)

486 existing lines in 6 files now uncovered.

3612 of 5978 relevant lines covered (60.42%)

39.42 hits per line

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

23.91

/src/SceneGraphDebugCommands.ts

import * as vscode from 'vscode';
import type { SceneGraphCommandResponse } from 'roku-debug';
import { SceneGraphDebugCommandController } from 'roku-debug';
import { util } from './util';

export class SceneGraphDebugCommands {
    private outputChannel: vscode.OutputChannel;
    private context: vscode.ExtensionContext;
    private host: string;

    public registerCommands(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel) {
        this.context = context;
        this.outputChannel = outputChannel;
        let subscriptions = context.subscriptions;

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofPause', async () => {
            await this.logCommandOutput(async (commandController) => commandController.bsprof('pause'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofResume', async () => {
            await this.logCommandOutput(async (commandController) => commandController.bsprof('resume'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofStatus', async () => {
            await this.logCommandOutput(async (commandController) => commandController.bsprof('status'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperf', async () => {
            await this.logCommandOutput(async (commandController) => commandController.chanperf());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperfChangeInterval', async () => {
            let interval = parseInt(await vscode.window.showInputBox({ placeHolder: 'seconds' }));
            if (!isNaN(interval)) {
                await this.logCommandOutput(async (commandController) => commandController.chanperf({ interval: interval }));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.clearLaunchCaches', async () => {
            await this.logCommandOutput(async (commandController) => commandController.clearLaunchCaches());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.fpsDisplay', async () => {
            let option = await vscode.window.showQuickPick(['toggle', 'on', 'off'], { placeHolder: 'Please select an option' });
            if (option) {
                await this.logCommandOutput(async (commandController) => commandController.fpsDisplay(option as 'toggle' | 'on' | 'off'));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.free', async () => {
            await this.logCommandOutput(async (commandController) => commandController.free());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.genkey', async () => {
            await this.logCommandOutput(async (commandController) => commandController.genkey());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.loadedTextures', async () => {
            await this.logCommandOutput(async (commandController) => commandController.loadedTextures());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.logrendezvous', async () => {
            let option = await vscode.window.showQuickPick(['status', 'on', 'off'], { placeHolder: 'Please select an option' });
            if (option) {
                await this.logCommandOutput(async (commandController) => commandController.logrendezvous(option as 'status' | 'on' | 'off'));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.plugins', async () => {
            await this.logCommandOutput(async (commandController) => commandController.plugins());
        }));

        // TODO: press? likely needs to go in the old area.
        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.press', async () => {
            let keys = (await vscode.window.showInputBox({ placeHolder: 'comma separated list of keys' })).split(',');
            if (keys.length > 1) {
                await this.logCommandOutput(async (commandController) => commandController.press(keys));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.r2d2bitmaps', async () => {
            await this.logCommandOutput(async (commandController) => commandController.r2d2Bitmaps());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.removePlugin', async () => {
            let pluginId = await vscode.window.showInputBox({ placeHolder: 'plugin_id' });

            if (pluginId) {
                await this.logCommandOutput(async (commandController) => commandController.removePlugin(pluginId));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesAll', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgnodes('all'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesRoots', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgnodes('roots'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesNodeId', async () => {
            let nodeId = await vscode.window.showInputBox({ placeHolder: 'node_id' });
            if (nodeId) {
                await this.logCommandOutput(async (commandController) => commandController.sgnodes(nodeId));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStart', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('start'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStop', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('stop'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfClear', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('clear'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfReport', async () => {
            await this.logCommandOutput(async (commandController) => commandController.sgperf('report'));
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.showkey', async () => {
            await this.logCommandOutput(async (commandController) => commandController.showkey());
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.brightscriptWarnings', async () => {
            let limit = parseInt(await vscode.window.showInputBox({ placeHolder: '100', validateInput: (value: string) => {
                if (isNaN(parseInt(value))) {
                    return 'Input must be a numeric value';
                }
            } }));

            if (!isNaN(limit)) {
                await this.logCommandOutput((commandController) => commandController.brightscriptWarnings(limit));
            }
        }));

        subscriptions.push(vscode.commands.registerCommand('extension.brightscript.custom8080Command', async () => {
            let command = await vscode.window.showInputBox({ placeHolder: 'custom command' });
            if (command) {
                await this.logCommandOutput(async (commandController) => commandController.exec(command));
            }
        }));
    }

    private async logCommandOutput(callback: (controller: SceneGraphDebugCommandController) => Promise<SceneGraphCommandResponse>) {
        await this.getRemoteHost();
        let response = await callback(new SceneGraphDebugCommandController(this.host));

        this.outputChannel.show();

        // The output channel seems to have a limit to the amount of output that can be displayed in a single log.
        // For this reason we split the output into groups of 20 lines and send each group. If we don't do this a lot of
        // the middle of the string gets cut out.
        let lines = (response?.error?.message ?? response.result.rawResponse).split('\n');
        let lineGroups = this.chunkArray(lines);

        // Log the command statement
        this.outputChannel.append(`>${response.command}\n`);

        // Log each group of 20 lines
        for (let lineGroup of lineGroups) {
            this.outputChannel.append(lineGroup.join('\n') + '\n');
        }
    }

    private chunkArray(arr: Array<any>, chunkSize = 20) {
        if (chunkSize <= 0) {
            return arr;
        }

        let chunks = [];
        for (let i = 0, len = arr.length; i < len; i += 20) {
            chunks.push(arr.slice(i, i + chunkSize));

        }

        return chunks;
    }

    public async getRemoteHost() {
        this.host = await this.context.workspaceState.get('remoteHost');
        if (!this.host) {
            let config = util.getConfiguration('brightscript.remoteControl');
            this.host = config.get('host');
            if (this.host === '${promptForHost}') {
                this.host = await vscode.window.showInputBox({
                    placeHolder: 'The IP address of your Roku device',
                    value: ''
                });
            }
        }
        if (!this.host) {
            throw new Error('Can\'t send command: host is required.');
        } else {
            await this.context.workspaceState.update('remoteHost', this.host);
        }
    }

}

export const sceneGraphDebugCommands = new SceneGraphDebugCommands();

1	import * as vscode from 'vscode';	1✔
2	import type { SceneGraphCommandResponse } from 'roku-debug';
3	import { SceneGraphDebugCommandController } from 'roku-debug';	1✔
4	import { util } from './util';	1✔
5
6	export class SceneGraphDebugCommands {	1✔
7	private outputChannel: vscode.OutputChannel;
8	private context: vscode.ExtensionContext;
9	private host: string;
10
11	public registerCommands(context: vscode.ExtensionContext, outputChannel: vscode.OutputChannel) {
12	this.context = context;	12✔
13	this.outputChannel = outputChannel;	12✔
14	let subscriptions = context.subscriptions;	12✔
15
16	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofPause', async () => {	12✔
UNCOV 17	await this.logCommandOutput(async (commandController) => commandController.bsprof('pause'));	×
18	}));
19
20	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofResume', async () => {	12✔
UNCOV 21	await this.logCommandOutput(async (commandController) => commandController.bsprof('resume'));	×
22	}));
23
24	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.bsprofStatus', async () => {	12✔
UNCOV 25	await this.logCommandOutput(async (commandController) => commandController.bsprof('status'));	×
26	}));
27
28	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperf', async () => {	12✔
UNCOV 29	await this.logCommandOutput(async (commandController) => commandController.chanperf());	×
30	}));
31
32	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.chanperfChangeInterval', async () => {	12✔
UNCOV 33	let interval = parseInt(await vscode.window.showInputBox({ placeHolder: 'seconds' }));	×
UNCOV 34	if (!isNaN(interval)) {	×
UNCOV 35	await this.logCommandOutput(async (commandController) => commandController.chanperf({ interval: interval }));	×
36	}
37	}));
38
39	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.clearLaunchCaches', async () => {	12✔
UNCOV 40	await this.logCommandOutput(async (commandController) => commandController.clearLaunchCaches());	×
41	}));
42
43	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.fpsDisplay', async () => {	12✔
UNCOV 44	let option = await vscode.window.showQuickPick(['toggle', 'on', 'off'], { placeHolder: 'Please select an option' });	×
UNCOV 45	if (option) {	×
UNCOV 46	await this.logCommandOutput(async (commandController) => commandController.fpsDisplay(option as 'toggle' \| 'on' \| 'off'));	×
47	}
48	}));
49
50	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.free', async () => {	12✔
UNCOV 51	await this.logCommandOutput(async (commandController) => commandController.free());	×
52	}));
53
54	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.genkey', async () => {	12✔
UNCOV 55	await this.logCommandOutput(async (commandController) => commandController.genkey());	×
56	}));
57
58	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.loadedTextures', async () => {	12✔
UNCOV 59	await this.logCommandOutput(async (commandController) => commandController.loadedTextures());	×
60	}));
61
62	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.logrendezvous', async () => {	12✔
UNCOV 63	let option = await vscode.window.showQuickPick(['status', 'on', 'off'], { placeHolder: 'Please select an option' });	×
UNCOV 64	if (option) {	×
UNCOV 65	await this.logCommandOutput(async (commandController) => commandController.logrendezvous(option as 'status' \| 'on' \| 'off'));	×
66	}
67	}));
68
69	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.plugins', async () => {	12✔
UNCOV 70	await this.logCommandOutput(async (commandController) => commandController.plugins());	×
71	}));
72
73	// TODO: press? likely needs to go in the old area.
74	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.press', async () => {	12✔
UNCOV 75	let keys = (await vscode.window.showInputBox({ placeHolder: 'comma separated list of keys' })).split(',');	×
UNCOV 76	if (keys.length > 1) {	×
UNCOV 77	await this.logCommandOutput(async (commandController) => commandController.press(keys));	×
78	}
79	}));
80
81	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.r2d2bitmaps', async () => {	12✔
UNCOV 82	await this.logCommandOutput(async (commandController) => commandController.r2d2Bitmaps());	×
83	}));
84
85	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.removePlugin', async () => {	12✔
UNCOV 86	let pluginId = await vscode.window.showInputBox({ placeHolder: 'plugin_id' });	×
87
UNCOV 88	if (pluginId) {	×
89	await this.logCommandOutput(async (commandController) => commandController.removePlugin(pluginId));	×
90	}
91	}));
92
93	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesAll', async () => {	12✔
UNCOV 94	await this.logCommandOutput(async (commandController) => commandController.sgnodes('all'));	×
95	}));
96
97	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesRoots', async () => {	12✔
UNCOV 98	await this.logCommandOutput(async (commandController) => commandController.sgnodes('roots'));	×
99	}));
100
101	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgnodesNodeId', async () => {	12✔
UNCOV 102	let nodeId = await vscode.window.showInputBox({ placeHolder: 'node_id' });	×
UNCOV 103	if (nodeId) {	×
UNCOV 104	await this.logCommandOutput(async (commandController) => commandController.sgnodes(nodeId));	×
105	}
106	}));
107
108	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStart', async () => {	12✔
UNCOV 109	await this.logCommandOutput(async (commandController) => commandController.sgperf('start'));	×
110	}));
111
112	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfStop', async () => {	12✔
UNCOV 113	await this.logCommandOutput(async (commandController) => commandController.sgperf('stop'));	×
114	}));
115
116	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfClear', async () => {	12✔
UNCOV 117	await this.logCommandOutput(async (commandController) => commandController.sgperf('clear'));	×
118	}));
119
120	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.sgperfReport', async () => {	12✔
UNCOV 121	await this.logCommandOutput(async (commandController) => commandController.sgperf('report'));	×
122	}));
123
124	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.showkey', async () => {	12✔
UNCOV 125	await this.logCommandOutput(async (commandController) => commandController.showkey());	×
126	}));
127
128	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.brightscriptWarnings', async () => {	12✔
UNCOV 129	let limit = parseInt(await vscode.window.showInputBox({ placeHolder: '100', validateInput: (value: string) => {	×
UNCOV 130	if (isNaN(parseInt(value))) {	×
UNCOV 131	return 'Input must be a numeric value';	×
132	}
133	} }));
134
UNCOV 135	if (!isNaN(limit)) {	×
UNCOV 136	await this.logCommandOutput((commandController) => commandController.brightscriptWarnings(limit));	×
137	}
138	}));
139
140	subscriptions.push(vscode.commands.registerCommand('extension.brightscript.custom8080Command', async () => {	12✔
UNCOV 141	let command = await vscode.window.showInputBox({ placeHolder: 'custom command' });	×
UNCOV 142	if (command) {	×
UNCOV 143	await this.logCommandOutput(async (commandController) => commandController.exec(command));	×
144	}
145	}));
146	}
147
148	private async logCommandOutput(callback: (controller: SceneGraphDebugCommandController) => Promise<SceneGraphCommandResponse>) {
UNCOV 149	await this.getRemoteHost();	×
UNCOV 150	let response = await callback(new SceneGraphDebugCommandController(this.host));	×
151
152	this.outputChannel.show();	×
153
154	// The output channel seems to have a limit to the amount of output that can be displayed in a single log.
155	// For this reason we split the output into groups of 20 lines and send each group. If we don't do this a lot of
156	// the middle of the string gets cut out.
UNCOV 157	let lines = (response?.error?.message ?? response.result.rawResponse).split('\n');	×
UNCOV 158	let lineGroups = this.chunkArray(lines);	×
159
160	// Log the command statement
161	this.outputChannel.append(`>${response.command}\n`);	×
162
163	// Log each group of 20 lines
164	for (let lineGroup of lineGroups) {	×
UNCOV 165	this.outputChannel.append(lineGroup.join('\n') + '\n');	×
166	}
167	}
168
169	private chunkArray(arr: Array<any>, chunkSize = 20) {	×
UNCOV 170	if (chunkSize <= 0) {	×
UNCOV 171	return arr;	×
172	}
173
174	let chunks = [];	×
UNCOV 175	for (let i = 0, len = arr.length; i < len; i += 20) {	×
UNCOV 176	chunks.push(arr.slice(i, i + chunkSize));	×
177
178	}
179
UNCOV 180	return chunks;	×
181	}
182
183	public async getRemoteHost() {
UNCOV 184	this.host = await this.context.workspaceState.get('remoteHost');	×
UNCOV 185	if (!this.host) {	×
UNCOV 186	let config = util.getConfiguration('brightscript.remoteControl');	×
187	this.host = config.get('host');	×
188	if (this.host === '${promptForHost}') {	×
189	this.host = await vscode.window.showInputBox({	×
190	placeHolder: 'The IP address of your Roku device',
191	value: ''
192	});
193	}
194	}
UNCOV 195	if (!this.host) {	×
196	throw new Error('Can\'t send command: host is required.');	×
197	} else {
UNCOV 198	await this.context.workspaceState.update('remoteHost', this.host);	×
199	}
200	}
201
202	}
203
204	export const sceneGraphDebugCommands = new SceneGraphDebugCommands();	1✔

rokucommunity / vscode-brightscript-language / 26235216720

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