#1928

Build # #1928

Build Type

push

Committed by

Commit Message

<a href="https://github.com/rokucommunity/roku-debug/commit/<a class=hub.com/rokucommunity/roku-debug/commit/e0ddfe00f3a6f0ac1dd816021807fb3f0eacec76">e0ddfe00f<a href="https://github.com/rokucommunity/roku-debug/commit/e0ddfe00f3a6f0ac1dd816021807fb3f0eacec76">">Merge </a><a class="double-link" href="https://github.com/rokucommunity/roku-debug/commit/<a class="double-link" href="https://github.com/rokucommunity/roku-debug/commit/086cfbe9e4f65f32d3bc43dca9c28022c4273e42">086cfbe9e</a>">086cfbe9e</a><a href="https://github.com/rokucommunity/roku-debug/commit/e0ddfe00f3a6f0ac1dd816021807fb3f0eacec76"> into 37b322a46">37b322a46</a>

Run Details

983 of 1876 branches covered (52.4%)

Branch coverage included in aggregate %.

77 of 77 new or added lines in 5 files covered. (100.0%)

2073 of 3565 relevant lines covered (58.15%)

15.79 hits per line

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

68.27

/src/util.ts

import * as fs from 'fs';
import * as fsExtra from 'fs-extra';
import * as net from 'net';
import * as url from 'url';
import type { SmartBuffer } from 'smart-buffer';
import type { BrightScriptDebugSession } from './debugSession/BrightScriptDebugSession';
import { LogOutputEvent } from './debugSession/Events';
import type { AssignmentStatement, Position, Range } from 'brighterscript';
import { DiagnosticSeverity, isDottedGetExpression, isIndexedGetExpression, isLiteralExpression, isVariableExpression, Parser } from 'brighterscript';
import { serializeError } from 'serialize-error';
import * as dns from 'dns';
import type { AdapterOptions } from './interfaces';

class Util {
    /**
     * If the path does not have a trailing slash, one is appended to it
     * @param dirPath
     */
    public ensureTrailingSlash(dirPath: string) {
        return dirPath.substr(dirPath.length - 1) !== '/' ? dirPath + '/' : dirPath;
    }

    /**
     * Determine if a file exists
     * @param filePath
     */
    public fileExists(filePath: string) {
        return new Promise((resolve) => {
            fsExtra.exists(filePath, resolve);
        });
    }

    /**
     * Determines if the given path is a file
     * @param filePathAbsolute
     */
    public async isFile(filePathAbsolute: string) {
        try {
            //get the full path to the file. This should be the same path for files, and the actual path for any symlinks
            let realPathAbsolute = fs.realpathSync(filePathAbsolute);
            let stat = await fsExtra.lstat(realPathAbsolute);
            return stat.isFile();
        } catch (e) {
            // lstatSync throws an error if path doesn't exist
            return false;
        }
    }

    /**
     * Removes any leading scheme in the file path
     * @param filePath
     */
    public removeFileScheme(filePath: string): string {
        let scheme = this.getFileScheme(filePath);
        if (scheme) {
            return filePath.substring(scheme.length);
        } else {
            return filePath;
        }
    }

    /**
     * Gets any leading scheme in the file path
     * @param filePath
     */
    public getFileScheme(filePath: string): string | null {
        return url.parse(filePath).protocol;
    }

    /**
     * Remove a single trailing newline from a string (\n or \r\n)
     */
    public removeTrailingNewline(value: string) {
        return value.replace(/(.*?)\r?\n$/, '$1');
    }

    /**
     * Reads the the manifest file and converts to a javascript object skipping empty lines and comments
     * @param path location of the manifest file
     */
    public async convertManifestToObject(path: string): Promise<Record<string, string> | undefined> {
        if (await this.fileExists(path) === false) {
            return undefined;
        } else {
            let fileContents = (await fsExtra.readFile(path)).toString();
            let manifestLines = fileContents.split('\n');

            let manifestValues = {};
            for (const line of manifestLines) {
                let match = /(\w+)=(.+)/.exec(line);
                if (match) {
                    manifestValues[match[1]] = match[2];
                    //add match in all lower case too (for consistency)
                    manifestValues[match[1]?.toLowerCase()] = match[2];
                }
            }

            return manifestValues;
        }
    }

    /**
     * Checks to see if the port is already in use
     * @param port target port to check
     */
    public async isPortInUse(port: number): Promise<boolean> {
        return new Promise<boolean>((resolve, reject) => {
            const tester = net.createServer()
                .once('error', (err: any) => {
                    if (err.code === 'EADDRINUSE') {
                        resolve(true);
                    } else {
                        reject(err);
                    }
                })
                .once('listening', () => tester.once('close', () => {
                    resolve(false);
                }).close())
                .listen(port);
        });
    }

    /**
     * Tries to read a string from the buffer and will throw an error if there is no null terminator.
     * @param {SmartBuffer} bufferReader
     */
    public readStringNT(bufferReader: SmartBuffer): string {
        // Find next null character (if one is not found, throw)
        let buffer = bufferReader.toBuffer();
        let foundNullTerminator = false;
        for (let i = bufferReader.readOffset; i < buffer.length; i++) {
            if (buffer[i] === 0x00) {
                foundNullTerminator = true;
                break;
            }
        }

        if (!foundNullTerminator) {
            throw new Error('Could not read buffer string as there is no null terminator.');
        }
        return bufferReader.readStringNT();
    }

    /**
     * A reference to the current debug session. Used for logging, and set in the debug session constructor
     */
    public _debugSession: BrightScriptDebugSession;

    /**
     * Write to the standard brightscript output log so users can see it. (This also writes to the debug server output channel, and the console)
     * @param message
     */
    public log(message: string) {
        if (this._debugSession) {
            this._debugSession.sendEvent(new LogOutputEvent(`DebugServer: ${message}`));
        }
    }

    /**
     * The vscode hover will occasionally forget to include the closing quotemark for quoted strings,
     * so this attempts to auto-insert a closing quotemark if an opening one was found but is missing the closing one
     * @param text
     */
    public ensureClosingQuote(text: string) {
        if (text.startsWith('"') && text.trim().endsWith('"') === false) {
            text = text.trim() + '"';
        }
        return text;
    }

    /**
     * Test if `position` is in `range`. If the position is at the edges, will return true.
     * Adapted from core vscode
     * @param range
     * @param position
     */
    public rangeContains(range: Range, position: Position) {
        if (position.line < range.start.line || position.line > range.end.line) {
            return false;
        }
        if (position.line === range.start.line && position.character < range.start.character) {
            return false;
        }
        if (position.line === range.end.line && position.character > range.end.character) {
            return false;
        }
        return true;
    }

    /**
     * Ensures that all roku-emitted beacons are entirely on their own lines
     */
    public ensureDebugPromptOnOwnLine(text: string) {
        const regexp = /^((.*?)Brightscript\s+Debugger>\s*)(.*?)$/gm;
        let match: RegExpExecArray;
        const splitIndexes = [] as number[];
        while ((match = regexp.exec(text))) {
            const leadingAndBeaconText = match[1];
            const leadingText = match[2];
            const trailingText = match[3];
            //if there is text before the beacon, split the line
            if (leadingText.length > 0) {
                splitIndexes.push(match.index + leadingText.length);
            }
            //if there is text after the beacon, split the line
            if (trailingText.length > 0) {
                splitIndexes.push(match.index + leadingAndBeaconText.length);
            }
        }

        let result = text;
        //inject newlines between each split index
        for (let i = splitIndexes.length - 1; i >= 0; i--) {
            const index = splitIndexes[i];
            result = result.substring(0, index) + '\n' + result.substring(index);
        }
        return result;
    }

    /**
     * Does the string end with the "Brightscript Debugger>" prompt?
     * @param responseText
     */
    public endsWithDebuggerPrompt(text: string) {
        let match = /Brightscript\s+Debugger>\s*$/im.exec(text.trim());
        return !!match;
    }

    /**
     * Does the string end with the "thread attached......" text, ignoring trailing whitespace.
     * explanation: https://regex101.com/r/pN6grB/1
     */
    public endsWithThreadAttachedText(text: string) {
        if (/thread\s+attached\s*:.*?\(\d*\).*?[\r\n\s]*$/i.exec(text)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Remove those pesky "Thread attached" messages and the debugger prompt following them.
     * explanation: https://regex101.com/r/OwAWdw/4
     */
    public removeThreadAttachedText(text: string) {
        const match = /^([\r\n\s]*thread\s+attached\s*:.*?\(\d*\).*?[\r\n\s]*brightscript\s*debugger>\s*)+/i.exec(text);
        if (match) {
            return text.substring(match[0].length);
        } else {
            return text;
        }
    }

    /**
     * Removes the trailing `Brightscript Debugger>` prompt if present. If not present, returns original value
     * @param value
     */
    public trimDebugPrompt(value: string) {
        const match = /(.*?)\r?\nBrightscript Debugger>\s*/is.exec(value);
        if (match) {
            return match[1];
        } else {
            return value;
        }
    }

    /**
     * Get the keys for a given variable expression, or undefined if the expression doesn't make sense.
     */
    public getVariablePath(expression: string): string[] {
        //HACK: assign to a variable so it turns into a valid expression, then we'll look at the right-hand-side
        const parser = Parser.parse(`__rokuDebugVar = ${expression}`);
        if (
            //quit if there are parse errors
            parser.diagnostics.find(x => x.severity === DiagnosticSeverity.Error) ||
            //quit if there are zero statements or more than one statement
            parser.ast.statements.length !== 1
        ) {
            return undefined;
        }
        let value = (parser.ast.statements[0] as AssignmentStatement).value;

        const parts = [] as string[];
        while (value) {
            if (isVariableExpression(value)) {
                parts.unshift(value.name.text);
                return parts;
            } else if (isDottedGetExpression(value)) {
                parts.unshift(value.name.text);
                value = value.obj;
            } else if (isIndexedGetExpression(value)) {
                if (isLiteralExpression(value.index)) {
                    parts.unshift(
                        value.index.token.text
                    );
                } else {
                    //if we found a non-literal value, this entire variable path is NOT a true variable path
                    return;
                }
                value = value.obj;
            } else {
                //not valid
                return;
            }
        }
    }

    /**
     * Given a full URL, convert any dns name into its IP address and then return the full URL with the name replaced
     */
    public async resolveUrl(url: string, skipCache = false) {
        //https://regex101.com/r/cSkoTx/1
        const [, protocol, host] = /^((?:http[s]?|ftp):\/\/)?([^:\/\s]+)(:\d+)?([^?#]+)?(\?[^#]+)?(#.*)?$/.exec(url) ?? [];
        if (host) {
            const ipAddress = await this.dnsLookup(host);
            url = protocol + ipAddress + url.substring(protocol.length + host.length);
        }
        return url;
    }

    /*
     * Look up the ip address for a hostname. This is cached for the lifetime of the app, or bypassed with the `skipCache` parameter
     * @param host
     * @param skipCache
     * @returns
     */
    public async dnsLookup(host: string, skipCache = false) {
        if (!this.dnsCache.has(host) || skipCache) {
            const result = await dns.promises.lookup(host);
            this.dnsCache.set(host, result.address ?? host);
        }
        return this.dnsCache.get(host);
    }

    private dnsCache = new Map<string, string>();

    /**
     * Is this expression the `print` keyword followed by a variable expression (like `a.b` or `a['b'].c`)
     * @param expression
     */
    public isPrintVarExpression(expression: string) {
        expression = expression.trim().toLowerCase();
        if (expression.startsWith('print') || expression.startsWith('?')) {
            const parts = this.getVariablePath(expression.replace(/^(print|\?)/, ''));
            if (parts?.length > 0) {
                return true;
            }
        }
        return false;
    }

    /*
     * Sleep for the given number of milliseconds
     * @param milliseconds
     * @returns
     */
    public sleep(milliseconds: number) {
        return new Promise(resolve => {
            setTimeout(resolve, milliseconds);
        });
    }

    public fence(data: string) {
        const fence = '--------------------';
        return `\n${fence}\n${data}\n${fence}\n`;
    }

    public formatTime(ms: number) {
        const allocate = msUnit => {
            const units = Math.trunc(ms / msUnit);
            ms -= units * msUnit;
            return units;
        };
        const hours = allocate(3600000);
        const minutes = allocate(60000);
        const seconds = allocate(1000);
        return `${hours > 0 ? hours + 'h' : ''}${minutes > 0 ? minutes + 'm' : ''}${seconds > 0 ? seconds + 's' : ''}${ms > 0 ? ms + 'ms' : ''}`;
    }

    public normalizeAdapterOptions(options: AdapterOptions) {
        options.brightScriptConsolePort ??= 8085;
        options.remotePort ??= 8060;
    }

    /**
     * Set an interval that can be cleared by calling the callback
     * @param intervalMs the number of milliseconds to wait for the next interval
     */
    public setInterval(callback: (cancel: () => void) => any, intervalMs: number) {
        const cancel = () => {
            clearInterval(handle);
        };
        const handle = setInterval(() => {
            callback(cancel);
        }, intervalMs);

        //call immediately
        callback(cancel);

        return cancel;
    }
}

export function defer<T>() {
    let _resolve: (value?: PromiseLike<T> | T) => void;
    let _reject: (reason?: any) => void;
    let promise = new Promise<T>((resolveValue, rejectValue) => {
        _resolve = resolveValue;
        _reject = rejectValue;
    });
    return {
        promise: promise,
        resolve: function resolve(value?: PromiseLike<T> | T) {
            if (!this.isResolved) {
                this.isResolved = true;
                _resolve(value);
                _resolve = undefined;
            } else {
                throw new Error(
                    `Attempted to resolve a promise that was already ${this.isResolved ? 'resolved' : 'rejected'}.` +
                    `New value: ${JSON.stringify(value)}`
                );
            }
        },
        reject: function reject(reason?: any) {
            if (!this.isCompleted) {
                this.isRejected = true;
                _reject(reason);
                _reject = undefined;
            } else {
                throw new Error(
                    `Attempted to reject a promise that was already ${this.isResolved ? 'resolved' : 'rejected'}.` +
                    `New error message: ${JSON.stringify(serializeError(reason))}`
                );
            }
        },
        isResolved: false,
        isRejected: false,
        get isCompleted() {
            return this.isResolved || this.isRejected;
        }
    };
}

export const util = new Util();
export interface Deferred<T> {
    promise: Promise<T>;
    resolve(value?: T);
    reject(error?: any);
}

1	import * as fs from 'fs';	1✔
2	import * as fsExtra from 'fs-extra';	1✔
3	import * as net from 'net';	1✔
4	import * as url from 'url';	1✔
5	import type { SmartBuffer } from 'smart-buffer';
6	import type { BrightScriptDebugSession } from './debugSession/BrightScriptDebugSession';
7	import { LogOutputEvent } from './debugSession/Events';	1✔
8	import type { AssignmentStatement, Position, Range } from 'brighterscript';
9	import { DiagnosticSeverity, isDottedGetExpression, isIndexedGetExpression, isLiteralExpression, isVariableExpression, Parser } from 'brighterscript';	1✔
10	import { serializeError } from 'serialize-error';	1✔
11	import * as dns from 'dns';	1✔
12	import type { AdapterOptions } from './interfaces';
13
14	class Util {
15	/**
16	* If the path does not have a trailing slash, one is appended to it
17	* @param dirPath
18	*/
19	public ensureTrailingSlash(dirPath: string) {
20	return dirPath.substr(dirPath.length - 1) !== '/' ? dirPath + '/' : dirPath;	2✔
21	}
22
23	/**
24	* Determine if a file exists
25	* @param filePath
26	*/
27	public fileExists(filePath: string) {
28	return new Promise((resolve) => {	10✔
29	fsExtra.exists(filePath, resolve);	10✔
30	});
31	}
32
33	/**
34	* Determines if the given path is a file
35	* @param filePathAbsolute
36	*/
37	public async isFile(filePathAbsolute: string) {
38	try {	52✔
39	//get the full path to the file. This should be the same path for files, and the actual path for any symlinks
40	let realPathAbsolute = fs.realpathSync(filePathAbsolute);	52✔
41	let stat = await fsExtra.lstat(realPathAbsolute);	52✔
42	return stat.isFile();	52✔
43	} catch (e) {
44	// lstatSync throws an error if path doesn't exist
45	return false;	×
46	}
47	}
48
49	/**
50	* Removes any leading scheme in the file path
51	* @param filePath
52	*/
53	public removeFileScheme(filePath: string): string {
54	let scheme = this.getFileScheme(filePath);	13✔
55	if (scheme) {	13✔
56	return filePath.substring(scheme.length);	11✔
57	} else {
58	return filePath;	2✔
59	}
60	}
61
62	/**
63	* Gets any leading scheme in the file path
64	* @param filePath
65	*/
66	public getFileScheme(filePath: string): string \| null {
67	return url.parse(filePath).protocol;	31✔
68	}
69
70	/**
71	* Remove a single trailing newline from a string (\n or \r\n)
72	*/
73	public removeTrailingNewline(value: string) {
74	return value.replace(/(.*?)\r?\n$/, '$1');	3✔
75	}
76
77	/**
78	* Reads the the manifest file and converts to a javascript object skipping empty lines and comments
79	* @param path location of the manifest file
80	*/
81	public async convertManifestToObject(path: string): Promise<Record<string, string> \| undefined> {
82	if (await this.fileExists(path) === false) {	8✔
83	return undefined;	2✔
84	} else {
85	let fileContents = (await fsExtra.readFile(path)).toString();	6✔
86	let manifestLines = fileContents.split('\n');	6✔
87
88	let manifestValues = {};	6✔
89	for (const line of manifestLines) {	6✔
90	let match = /(\w+)=(.+)/.exec(line);	28✔
91	if (match) {	28✔
92	manifestValues[match[1]] = match[2];	20✔
93	//add match in all lower case too (for consistency)
94	manifestValues[match[1]?.toLowerCase()] = match[2];	20!
95	}
96	}
97
98	return manifestValues;	6✔
99	}
100	}
101
102	/**
103	* Checks to see if the port is already in use
104	* @param port target port to check
105	*/
106	public async isPortInUse(port: number): Promise<boolean> {
107	return new Promise<boolean>((resolve, reject) => {	2✔
108	const tester = net.createServer()	2✔
109	.once('error', (err: any) => {
110	if (err.code === 'EADDRINUSE') {	1!
111	resolve(true);	1✔
112	} else {
113	reject(err);	×
114	}
115	})
116	.once('listening', () => tester.once('close', () => {	1✔
117	resolve(false);	1✔
118	}).close())
119	.listen(port);
120	});
121	}
122
123	/**
124	* Tries to read a string from the buffer and will throw an error if there is no null terminator.
125	* @param {SmartBuffer} bufferReader
126	*/
127	public readStringNT(bufferReader: SmartBuffer): string {
128	// Find next null character (if one is not found, throw)
129	let buffer = bufferReader.toBuffer();	28✔
130	let foundNullTerminator = false;	28✔
131	for (let i = bufferReader.readOffset; i < buffer.length; i++) {	28✔
132	if (buffer[i] === 0x00) {	284✔
133	foundNullTerminator = true;	28✔
134	break;	28✔
135	}
136	}
137
138	if (!foundNullTerminator) {	28!
139	throw new Error('Could not read buffer string as there is no null terminator.');	×
140	}
141	return bufferReader.readStringNT();	28✔
142	}
143
144	/**
145	* A reference to the current debug session. Used for logging, and set in the debug session constructor
146	*/
147	public _debugSession: BrightScriptDebugSession;
148
149	/**
150	* Write to the standard brightscript output log so users can see it. (This also writes to the debug server output channel, and the console)
151	* @param message
152	*/
153	public log(message: string) {
154	if (this._debugSession) {	4!
155	this._debugSession.sendEvent(new LogOutputEvent(`DebugServer: ${message}`));	4✔
156	}
157	}
158
159	/**
160	* The vscode hover will occasionally forget to include the closing quotemark for quoted strings,
161	* so this attempts to auto-insert a closing quotemark if an opening one was found but is missing the closing one
162	* @param text
163	*/
164	public ensureClosingQuote(text: string) {
165	if (text.startsWith('"') && text.trim().endsWith('"') === false) {	4✔
166	text = text.trim() + '"';	1✔
167	}
168	return text;	4✔
169	}
170
171	/**
172	* Test if `position` is in `range`. If the position is at the edges, will return true.
173	* Adapted from core vscode
174	* @param range
175	* @param position
176	*/
177	public rangeContains(range: Range, position: Position) {
178	if (position.line < range.start.line \|\| position.line > range.end.line) {	×
179	return false;	×
180	}
181	if (position.line === range.start.line && position.character < range.start.character) {	×
182	return false;	×
183	}
184	if (position.line === range.end.line && position.character > range.end.character) {	×
185	return false;	×
186	}
187	return true;	×
188	}
189
190	/**
191	* Ensures that all roku-emitted beacons are entirely on their own lines
192	*/
193	public ensureDebugPromptOnOwnLine(text: string) {
194	const regexp = /^((.?)Brightscript\s+Debugger>\s)(.*?)$/gm;	25✔
195	let match: RegExpExecArray;
196	const splitIndexes = [] as number[];	25✔
197	while ((match = regexp.exec(text))) {	25✔
198	const leadingAndBeaconText = match[1];	25✔
199	const leadingText = match[2];	25✔
200	const trailingText = match[3];	25✔
201	//if there is text before the beacon, split the line
202	if (leadingText.length > 0) {	25✔
203	splitIndexes.push(match.index + leadingText.length);	3✔
204	}
205	//if there is text after the beacon, split the line
206	if (trailingText.length > 0) {	25✔
207	splitIndexes.push(match.index + leadingAndBeaconText.length);	5✔
208	}
209	}
210
211	let result = text;	25✔
212	//inject newlines between each split index
213	for (let i = splitIndexes.length - 1; i >= 0; i--) {	25✔
214	const index = splitIndexes[i];	8✔
215	result = result.substring(0, index) + '\n' + result.substring(index);	8✔
216	}
217	return result;	25✔
218	}
219
220	/**
221	* Does the string end with the "Brightscript Debugger>" prompt?
222	* @param responseText
223	*/
224	public endsWithDebuggerPrompt(text: string) {
225	let match = /Brightscript\s+Debugger>\s*$/im.exec(text.trim());	42✔
226	return !!match;	42✔
227	}
228
229	/**
230	* Does the string end with the "thread attached......" text, ignoring trailing whitespace.
231	* explanation: https://regex101.com/r/pN6grB/1
232	*/
233	public endsWithThreadAttachedText(text: string) {
234	if (/thread\s+attached\s:.?\(\d\).?[\r\n\s]*$/i.exec(text)) {	12✔
235	return true;	5✔
236	} else {
237	return false;	7✔
238	}
239	}
240
241	/**
242	* Remove those pesky "Thread attached" messages and the debugger prompt following them.
243	* explanation: https://regex101.com/r/OwAWdw/4
244	*/
245	public removeThreadAttachedText(text: string) {
246	const match = /^([\r\n\s]thread\s+attached\s:.?\(\d\).?[\r\n\s]brightscript\sdebugger>\s)+/i.exec(text);	24✔
247	if (match) {	24✔
248	return text.substring(match[0].length);	2✔
249	} else {
250	return text;	22✔
251	}
252	}
253
254	/**
255	* Removes the trailing `Brightscript Debugger>` prompt if present. If not present, returns original value
256	* @param value
257	*/
258	public trimDebugPrompt(value: string) {
259	const match = /(.?)\r?\nBrightscript Debugger>\s/is.exec(value);	11✔
260	if (match) {	11✔
261	return match[1];	2✔
262	} else {
263	return value;	9✔
264	}
265	}
266
267	/**
268	* Get the keys for a given variable expression, or undefined if the expression doesn't make sense.
269	*/
270	public getVariablePath(expression: string): string[] {
271	//HACK: assign to a variable so it turns into a valid expression, then we'll look at the right-hand-side
272	const parser = Parser.parse(`__rokuDebugVar = ${expression}`);	45✔
273	if (	45✔
274	//quit if there are parse errors
275	parser.diagnostics.find(x => x.severity === DiagnosticSeverity.Error) \|\|	6✔
276	//quit if there are zero statements or more than one statement
277	parser.ast.statements.length !== 1
278	) {
279	return undefined;	6✔
280	}
281	let value = (parser.ast.statements[0] as AssignmentStatement).value;	39✔
282
283	const parts = [] as string[];	39✔
284	while (value) {	39✔
285	if (isVariableExpression(value)) {	77✔
286	parts.unshift(value.name.text);	35✔
287	return parts;	35✔
288	} else if (isDottedGetExpression(value)) {	42✔
289	parts.unshift(value.name.text);	17✔
290	value = value.obj;	17✔
291	} else if (isIndexedGetExpression(value)) {	25✔
292	if (isLiteralExpression(value.index)) {	23✔
293	parts.unshift(	21✔
294	value.index.token.text
295	);
296	} else {
297	//if we found a non-literal value, this entire variable path is NOT a true variable path
298	return;	2✔
299	}
300	value = value.obj;	21✔
301	} else {
302	//not valid
303	return;	2✔
304	}
305	}
306	}
307
308	/**
309	* Given a full URL, convert any dns name into its IP address and then return the full URL with the name replaced
310	*/
311	public async resolveUrl(url: string, skipCache = false) {	×
312	//https://regex101.com/r/cSkoTx/1
313	const [, protocol, host] = /^((?:http[s]?\|ftp):\/\/)?([^:\/\s]+)(:\d+)?([^?#]+)?(\?[^#]+)?(#.*)?$/.exec(url) ?? [];	×
314	if (host) {	×
315	const ipAddress = await this.dnsLookup(host);	×
316	url = protocol + ipAddress + url.substring(protocol.length + host.length);	×
317	}
318	return url;	×
319	}
320
321	/*
322	* Look up the ip address for a hostname. This is cached for the lifetime of the app, or bypassed with the `skipCache` parameter
323	* @param host
324	* @param skipCache
325	* @returns
326	*/
327	public async dnsLookup(host: string, skipCache = false) {	×
328	if (!this.dnsCache.has(host) \|\| skipCache) {	×
329	const result = await dns.promises.lookup(host);	×
330	this.dnsCache.set(host, result.address ?? host);	×
331	}
332	return this.dnsCache.get(host);	×
333	}
334
335	private dnsCache = new Map<string, string>();	1✔
336
337	/**
338	* Is this expression the `print` keyword followed by a variable expression (like `a.b` or `a['b'].c`)
339	* @param expression
340	*/
341	public isPrintVarExpression(expression: string) {
342	expression = expression.trim().toLowerCase();	14✔
343	if (expression.startsWith('print') \|\| expression.startsWith('?')) {	14✔
344	const parts = this.getVariablePath(expression.replace(/^(print\|\?)/, ''));	12✔
345	if (parts?.length > 0) {	12✔
346	return true;	10✔
347	}
348	}
349	return false;	4✔
350	}
351
352	/*
353	* Sleep for the given number of milliseconds
354	* @param milliseconds
355	* @returns
356	*/
357	public sleep(milliseconds: number) {
358	return new Promise(resolve => {	14✔
359	setTimeout(resolve, milliseconds);	14✔
360	});
361	}
362
363	public fence(data: string) {
364	const fence = '--------------------';	25✔
365	return `\n${fence}\n${data}\n${fence}\n`;	25✔
366	}
367
368	public formatTime(ms: number) {
369	const allocate = msUnit => {	×
370	const units = Math.trunc(ms / msUnit);	×
371	ms -= units * msUnit;	×
372	return units;	×
373	};
374	const hours = allocate(3600000);	×
375	const minutes = allocate(60000);	×
376	const seconds = allocate(1000);	×
377	return `${hours > 0 ? hours + 'h' : ''}${minutes > 0 ? minutes + 'm' : ''}${seconds > 0 ? seconds + 's' : ''}${ms > 0 ? ms + 'ms' : ''}`;	×
378	}
379
380	public normalizeAdapterOptions(options: AdapterOptions) {
381	options.brightScriptConsolePort ??= 8085;	10!
382	options.remotePort ??= 8060;	10!
383	}
384
385	/**
386	* Set an interval that can be cleared by calling the callback
387	* @param intervalMs the number of milliseconds to wait for the next interval
388	*/
389	public setInterval(callback: (cancel: () => void) => any, intervalMs: number) {
390	const cancel = () => {	3✔
391	clearInterval(handle);	3✔
392	};
393	const handle = setInterval(() => {	3✔
394	callback(cancel);	×
395	}, intervalMs);
396
397	//call immediately
398	callback(cancel);	3✔
399
400	return cancel;	3✔
401	}
402	}
403
404	export function defer<T>() {	1✔
405	let _resolve: (value?: PromiseLike<T> \| T) => void;
406	let _reject: (reason?: any) => void;
407	let promise = new Promise<T>((resolveValue, rejectValue) => {	71✔
408	_resolve = resolveValue;	71✔
409	_reject = rejectValue;	71✔
410	});
411	return {	71✔
412	promise: promise,
413	resolve: function resolve(value?: PromiseLike<T> \| T) {
414	if (!this.isResolved) {	20!
415	this.isResolved = true;	20✔
416	_resolve(value);	20✔
417	_resolve = undefined;	20✔
418	} else {
419	throw new Error(	×
420	`Attempted to resolve a promise that was already ${this.isResolved ? 'resolved' : 'rejected'}.` +	×
421	`New value: ${JSON.stringify(value)}`
422	);
423	}
424	},
425	reject: function reject(reason?: any) {
426	if (!this.isCompleted) {	×
427	this.isRejected = true;	×
428	_reject(reason);	×
429	_reject = undefined;	×
430	} else {
431	throw new Error(	×
432	`Attempted to reject a promise that was already ${this.isResolved ? 'resolved' : 'rejected'}.` +	×
433	`New error message: ${JSON.stringify(serializeError(reason))}`
434	);
435	}
436	},
437	isResolved: false,
438	isRejected: false,
439	get isCompleted() {
440	return this.isResolved \|\| this.isRejected;	×
441	}
442	};
443	}
444
445	export const util = new Util();	1✔
446	export interface Deferred<T> {
447	promise: Promise<T>;
448	resolve(value?: T);
449	reject(error?: any);
450	}

rokucommunity / roku-debug / #1928

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