#1981

Build # #1981

Build Type

push

Committed by

Commit Message

<a href="https://github.com/rokucommunity/roku-debug/commit/<a class=hub.com/rokucommunity/roku-debug/commit/2fac6415773c6ae3bd751576cfa1901e1a95b3ca">2fac64157<a href="https://github.com/rokucommunity/roku-debug/commit/2fac6415773c6ae3bd751576cfa1901e1a95b3ca">">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/422cd0a89d89da7e96a816517bfcdb0b45d55c32">422cd0a89</a>">422cd0a89</a><a href="https://github.com/rokucommunity/roku-debug/commit/2fac6415773c6ae3bd751576cfa1901e1a95b3ca"> into 5fadd87c5">5fadd87c5</a>

Run Details

999 of 1900 branches covered (52.58%)

Branch coverage included in aggregate %.

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

2082 of 3571 relevant lines covered (58.3%)

15.83 hits per line

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

80.0

/src/FileUtils.ts

import * as findInFiles from 'find-in-files';
import * as fsExtra from 'fs-extra';
import * as glob from 'glob';
import * as path from 'path';
import { promisify } from 'util';
import { util as rokuDeployUtil } from 'roku-deploy';
const globp = promisify(glob);

export class FileUtils {

    /**
     * Determine if the `subjectPath` contains and also ends with the test path
     * @param subjectPath the path that `testPath` should be found within
     * @param testPath the path that the `subjectPath` should end with
     */
    public pathEndsWith(subjectPath: string, testPath: string) {
        subjectPath = this.standardizePath(subjectPath);
        testPath = this.standardizePath(testPath);
        let idx = subjectPath.indexOf(testPath);
        return (idx > -1 && subjectPath.endsWith(testPath));
    }

    /**
     * Determines if the `subject` path includes `search` path, with case sensitive comparison
     * @param subject
     * @param search
     */
    public pathIncludesCaseInsensitive(subject: string, search: string) {
        if (!subject || !search) {
            return false;
        }
        return path.normalize(subject.toLowerCase()).includes(path.normalize(search.toLowerCase()));
    }

    /**
     * Replace the first instance of `search` in `subject` with `replacement`
     */
    public replaceCaseInsensitive(subject: string, search: string, replacement: string) {
        let idx = subject.toLowerCase().indexOf(search.toLowerCase());
        if (idx > -1) {
            let result = subject.substring(0, idx) + replacement + subject.substring(idx + search.length);
            return result;
        } else {
            return subject;
        }
    }

    /**
     * Given a `directoryPath`, find and return all file paths relative to the `directoryPath`
     * @param directoryPath
     */
    public async getAllRelativePaths(directoryPath: string) {
        //normalize the path
        directoryPath = this.removeTrailingSlash(
            path.normalize(directoryPath)
        );

        let paths = await globp(path.join(directoryPath, '**/*'));
        for (let i = 0; i < paths.length; i++) {
            //make the path relative (+1 for removing the slash)
            paths[i] = paths[i].substring(directoryPath.length + 1);
        }
        return paths;
    }

    /**
     * Given a partial file path (truncated path from Roku telnet console),
     * search through the staging directory and find any paths that appear to
     * match the partial file path
     * @param partialFilePath the partial file path to search for
     * @param directoryPath the path to the directory to search through
     * @returns a relative path to the first match found in the directory
     */
    public async findPartialFileInDirectory(partialFilePath: string, directoryPath: string) {
        //the debugger path was truncated, so try and map it to a file in the outdir
        partialFilePath = this.standardizePath(
            this.removeFileTruncation(partialFilePath)
        );

        //find any files from the outDir that end the same as this file
        let results: string[] = [];
        let relativePaths = await this.getAllRelativePaths(directoryPath);
        for (let relativePath of relativePaths) {
            //if the staging path looks like the debugger path, keep it for now
            if (this.pathEndsWith(relativePath, partialFilePath)) {
                results.push(relativePath);
            }
        }

        //TODO is there something more we should do about finding multiple matches?
        if (results.length > 1) {
            console.warn(
                `Found multiple paths in '${directoryPath}' that match '${partialFilePath}'. Returning the first result, but you should consider renaming files in longer file paths to something unique`
            );
        }

        //return the first path found (or undefined if no results found);
        return results[0];
    }

    /**
     * The Roku telnet debugger truncates file paths, so this removes that leading truncation piece.
     * This removes 0 or more leading dots, followed by 0 or more leading slashes
     * @param filePath
     */
    public removeFileTruncation(filePath: string) {
        return filePath.replace(/^\.*[\/\\]*/, '');
    }

    /**
     * Given a relative file path, and a list of directories, find the first directory that contains the relative file.
     * This is basically a utility function for the sourceDirs concept
     * @param relativeFilePath - the path to the item relative to each `directoryPath`
     * @param directoryPaths - an array of directory paths
     * @returns the first path that was found to exist, or undefined if the file was not found in any of the `directoryPaths`
     */
    public async findFirstRelativeFile(relativeFilePath: string, directoryPaths: string[]) {
        for (let directoryPath of directoryPaths) {
            let fullPath = path.normalize(path.join(directoryPath, relativeFilePath));
            if (await fsExtra.pathExists(fullPath)) {
                return fullPath;
            }
        }
    }

    /**
     * Determine if the filename ends with one of the specified extensions
     */
    public hasAnyExtension(fileName: string, extensions: string[]) {
        let ext = path.extname(fileName);
        return extensions.includes(ext);
    }

    /**
     * Given a path to a directory, and an absolute path to a file,
     * get the relative file path (relative to the containingFolderPath)
     */
    public getRelativePath(containingFolderPath: string, filePathAbsolute: string) {
        return fileUtils.replaceCaseInsensitive(filePathAbsolute, containingFolderPath, '');
    }

    /**
     * Find the first `directoryPath` that is a parent to `filePathAbsolute`
     * @param filePathAbsolute - the absolute path to the file
     * @param directoryPaths - a list of directories where this file might reside
     */
    public findFirstParent(filePathAbsolute: string, directoryPaths: string[]) {
        filePathAbsolute = this.standardizePath(filePathAbsolute);
        for (let directoryPath of directoryPaths) {
            directoryPath = this.standardizePath(directoryPath);
            if (filePathAbsolute.startsWith(directoryPath)) {
                return directoryPath;
            }
        }
    }

    /**
     * Find the number at the end of component library prefix at the end of the file.
     * (i.e. "pkg:/source/main_lib1.brs" returns 1)
     * All files in component libraries are renamed to include the component library index as the ending portion of the filename,
     * which is necessary because the Roku debugger doesn't tell you which component library a file came from.
     */
    public getComponentLibraryIndexFromFileName(filePath: string, postfix: string) {
        let regex = new RegExp(postfix + '(\\d+)');
        let match = regex.exec(filePath);
        let result: number | undefined;
        if (match) {
            result = parseInt(match[1]);
            if (isNaN(result)) {
                result = undefined;
            }
        }
        return result;
    }

    /**
     * Append a postfix to the filename BEFORE its file extension
     */
    public postfixFilePath(filePath: string, postfix: string, fileExtensions: string[]) {
        let parsedPath = path.parse(filePath);

        if (fileExtensions.includes(parsedPath.ext)) {
            const regexp = new RegExp(parsedPath.ext + '$', 'i');
            return filePath.replace(regexp, postfix + parsedPath.ext);
        } else {
            return filePath;
        }
    }

    /**
     * Given a file path, return a new path with the component library postfix removed
     */
    public unPostfixFilePath(filePath: string, postfix: string) {
        let parts = path.parse(filePath);
        const search = `${postfix}${parts.ext}`;
        if (filePath.toLowerCase().endsWith(search.toLowerCase())) {
            return fileUtils.replaceCaseInsensitive(filePath, search, parts.ext);
        } else {
            return filePath;
        }
    }

    /**
     * Replace all directory separators with current OS separators,
     * force all drive letters to lower case (because that's what VSCode does sometimes so this makes it consistent)
     * @param thePath
     */
    public standardizePath(thePath: string) {
        if (!thePath) {
            return thePath;
        }
        let normalizedPath = path.normalize(
            thePath.replace(/[\/\\]+/g, path.sep)
        );
        //force the drive letter to lower case
        normalizedPath = this.driveLetterToLower(normalizedPath);
        return normalizedPath;
    }

    /**
     * Force the drive letter to lower case
     * @param fullPath
     */
    public driveLetterToLower(fullPath: string) {
        if (fullPath) {
            let firstCharCode = fullPath.charCodeAt(0);
            if (
                //is upper case A-Z
                firstCharCode >= 65 && firstCharCode <= 90 &&
                //next char is colon
                fullPath[1] === ':'
            ) {
                fullPath = fullPath[0].toLowerCase() + fullPath.substring(1);
            }
        }
        return fullPath;
    }

    /**
     * Get a file url for a file path (i.e. file:///C:/projects/Something or file:///projects/something
     * @param fullPath
     */
    public getFileProtocolPath(fullPath: string) {
        if (fullPath.startsWith('file://')) {
            return fullPath;
        }
        let result: string;
        if (fullPath.startsWith('/') || fullPath.startsWith('\\')) {
            result = `file://${fullPath}`;
        } else {
            result = `file:///${fullPath}`;
        }
        return result;
    }

    /**
     * Given a path to a folder, search all files until an entry point is found.
     * (An entry point is a function that roku uses as the Main function to start the program).
     * @param projectPath - a path to a Roku project
     */
    public async findEntryPoint(projectPath: string) {
        let results = {
            ...await findInFiles.find({ term: 'sub\\s+RunScreenSaver\\s*\\(', flags: 'ig' }, projectPath, /.*\.brs/),
            ...await findInFiles.find({ term: 'function\\s+RunScreenSaver\\s*\\(', flags: 'ig' }, projectPath, /.*\.brs/),
            ...await findInFiles.find({ term: 'sub\\s+RunUserInterface\\s*\\(', flags: 'ig' }, projectPath, /.*\.brs/),
            ...await findInFiles.find({ term: 'function\\s+RunUserInterface\\s*\\(', flags: 'ig' }, projectPath, /.*\.brs/),
            ...await findInFiles.find({ term: 'sub\\s+main\\s*\\(', flags: 'ig' }, projectPath, /.*\.brs/),
            ...await findInFiles.find({ term: 'function\\s+main\\s*\\(', flags: 'ig' }, projectPath, /.*\.brs/)
        };
        let keys = Object.keys(results);
        if (keys.length === 0) {
            throw new Error('Unable to find an entry point. Please make sure that you have a RunUserInterface, RunScreenSaver, or Main sub/function declared in your BrightScript project');
        }

        let entryPath = keys[0];

        let entryLineContents = results[entryPath].line[0];

        let lineNumber: number;
        //load the file contents
        let contents = await fsExtra.readFile(entryPath);
        let lines = contents.toString().split(/\r?\n/g);
        //loop through the lines until we find the entry line
        for (let i = 0; i < lines.length; i++) {
            let line = lines[i];
            if (line.includes(entryLineContents)) {
                lineNumber = i + 1;
                break;
            }
        }
        let relativePath = fileUtils.removeLeadingSlash(
            rokuDeployUtil.stringReplaceInsensitive(entryPath, projectPath, '')
        );

        return {
            relativePath: relativePath,
            pathAbsolute: entryPath,
            contents: entryLineContents,
            lineNumber: lineNumber
        };
    }

    /**
     * If a string has a leading slash, remove it
     */
    public removeLeadingSlash(thePath: string) {
        if (typeof thePath === 'string') {
            while (thePath.startsWith('/') || thePath.startsWith('\\')) {
                thePath = thePath.substring(1);
            }
        }
        return thePath;
    }

    /**
     * If a string has a trailing slash, remove it
     */
    public removeTrailingSlash(thePath: string) {
        if (typeof thePath === 'string') {
            while (thePath.endsWith('/') || thePath.endsWith('\\')) {
                thePath = thePath.slice(0, -1);
            }
        }
        return thePath;
    }
}

export let fileUtils = new FileUtils();

/**
 * A tagged template literal function for standardizing the path.
 */
export function standardizePath(stringParts, ...expressions: any[]) {
    let result = [];
    for (let i = 0; i < stringParts.length; i++) {
        result.push(stringParts[i], expressions[i]);
    }
    return fileUtils.standardizePath(
        result.join('')
    );
}

1	import * as findInFiles from 'find-in-files';	1✔
2	import * as fsExtra from 'fs-extra';	1✔
3	import * as glob from 'glob';	1✔
4	import * as path from 'path';	1✔
5	import { promisify } from 'util';	1✔
6	import { util as rokuDeployUtil } from 'roku-deploy';	1✔
7	const globp = promisify(glob);	1✔
8
9	export class FileUtils {	1✔
10
11	/**
12	* Determine if the `subjectPath` contains and also ends with the test path
13	* @param subjectPath the path that `testPath` should be found within
14	* @param testPath the path that the `subjectPath` should end with
15	*/
16	public pathEndsWith(subjectPath: string, testPath: string) {
17	subjectPath = this.standardizePath(subjectPath);	28✔
18	testPath = this.standardizePath(testPath);	28✔
19	let idx = subjectPath.indexOf(testPath);	28✔
20	return (idx > -1 && subjectPath.endsWith(testPath));	28✔
21	}
22
23	/**
24	* Determines if the `subject` path includes `search` path, with case sensitive comparison
25	* @param subject
26	* @param search
27	*/
28	public pathIncludesCaseInsensitive(subject: string, search: string) {
29	if (!subject \|\| !search) {	×
30	return false;	×
31	}
32	return path.normalize(subject.toLowerCase()).includes(path.normalize(search.toLowerCase()));	×
33	}
34
35	/**
36	* Replace the first instance of `search` in `subject` with `replacement`
37	*/
38	public replaceCaseInsensitive(subject: string, search: string, replacement: string) {
39	let idx = subject.toLowerCase().indexOf(search.toLowerCase());	107✔
40	if (idx > -1) {	107!
41	let result = subject.substring(0, idx) + replacement + subject.substring(idx + search.length);	107✔
42	return result;	107✔
43	} else {
44	return subject;	×
45	}
46	}
47
48	/**
49	* Given a `directoryPath`, find and return all file paths relative to the `directoryPath`
50	* @param directoryPath
51	*/
52	public async getAllRelativePaths(directoryPath: string) {
53	//normalize the path
54	directoryPath = this.removeTrailingSlash(	3✔
55	path.normalize(directoryPath)
56	);
57
58	let paths = await globp(path.join(directoryPath, '*/'));	3✔
59	for (let i = 0; i < paths.length; i++) {	3✔
60	//make the path relative (+1 for removing the slash)
61	paths[i] = paths[i].substring(directoryPath.length + 1);	76✔
62	}
63	return paths;	3✔
64	}
65
66	/**
67	* Given a partial file path (truncated path from Roku telnet console),
68	* search through the staging directory and find any paths that appear to
69	* match the partial file path
70	* @param partialFilePath the partial file path to search for
71	* @param directoryPath the path to the directory to search through
72	* @returns a relative path to the first match found in the directory
73	*/
74	public async findPartialFileInDirectory(partialFilePath: string, directoryPath: string) {
75	//the debugger path was truncated, so try and map it to a file in the outdir
76	partialFilePath = this.standardizePath(	7✔
77	this.removeFileTruncation(partialFilePath)
78	);
79
80	//find any files from the outDir that end the same as this file
81	let results: string[] = [];	7✔
82	let relativePaths = await this.getAllRelativePaths(directoryPath);	7✔
83	for (let relativePath of relativePaths) {	7✔
84	//if the staging path looks like the debugger path, keep it for now
85	if (this.pathEndsWith(relativePath, partialFilePath)) {	15✔
86	results.push(relativePath);	6✔
87	}
88	}
89
90	//TODO is there something more we should do about finding multiple matches?
91	if (results.length > 1) {	7✔
92	console.warn(	1✔
93	`Found multiple paths in '${directoryPath}' that match '${partialFilePath}'. Returning the first result, but you should consider renaming files in longer file paths to something unique`
94	);
95	}
96
97	//return the first path found (or undefined if no results found);
98	return results[0];	7✔
99	}
100
101	/**
102	* The Roku telnet debugger truncates file paths, so this removes that leading truncation piece.
103	* This removes 0 or more leading dots, followed by 0 or more leading slashes
104	* @param filePath
105	*/
106	public removeFileTruncation(filePath: string) {
107	return filePath.replace(/^\.[\/\\]/, '');	11✔
108	}
109
110	/**
111	* Given a relative file path, and a list of directories, find the first directory that contains the relative file.
112	* This is basically a utility function for the sourceDirs concept
113	* @param relativeFilePath - the path to the item relative to each `directoryPath`
114	* @param directoryPaths - an array of directory paths
115	* @returns the first path that was found to exist, or undefined if the file was not found in any of the `directoryPaths`
116	*/
117	public async findFirstRelativeFile(relativeFilePath: string, directoryPaths: string[]) {
118	for (let directoryPath of directoryPaths) {	15✔
119	let fullPath = path.normalize(path.join(directoryPath, relativeFilePath));	13✔
120	if (await fsExtra.pathExists(fullPath)) {	13✔
121	return fullPath;	6✔
122	}
123	}
124	}
125
126	/**
127	* Determine if the filename ends with one of the specified extensions
128	*/
129	public hasAnyExtension(fileName: string, extensions: string[]) {
130	let ext = path.extname(fileName);	×
131	return extensions.includes(ext);	×
132	}
133
134	/**
135	* Given a path to a directory, and an absolute path to a file,
136	* get the relative file path (relative to the containingFolderPath)
137	*/
138	public getRelativePath(containingFolderPath: string, filePathAbsolute: string) {
139	return fileUtils.replaceCaseInsensitive(filePathAbsolute, containingFolderPath, '');	12✔
140	}
141
142	/**
143	* Find the first `directoryPath` that is a parent to `filePathAbsolute`
144	* @param filePathAbsolute - the absolute path to the file
145	* @param directoryPaths - a list of directories where this file might reside
146	*/
147	public findFirstParent(filePathAbsolute: string, directoryPaths: string[]) {
148	filePathAbsolute = this.standardizePath(filePathAbsolute);	46✔
149	for (let directoryPath of directoryPaths) {	46✔
150	directoryPath = this.standardizePath(directoryPath);	51✔
151	if (filePathAbsolute.startsWith(directoryPath)) {	51✔
152	return directoryPath;	23✔
153	}
154	}
155	}
156
157	/**
158	* Find the number at the end of component library prefix at the end of the file.
159	* (i.e. "pkg:/source/main_lib1.brs" returns 1)
160	* All files in component libraries are renamed to include the component library index as the ending portion of the filename,
161	* which is necessary because the Roku debugger doesn't tell you which component library a file came from.
162	*/
163	public getComponentLibraryIndexFromFileName(filePath: string, postfix: string) {
164	let regex = new RegExp(postfix + '(\\d+)');	20✔
165	let match = regex.exec(filePath);	20✔
166	let result: number \| undefined;
167	if (match) {	20✔
168	result = parseInt(match[1]);	6✔
169	if (isNaN(result)) {	6!
170	result = undefined;	×
171	}
172	}
173	return result;	20✔
174	}
175
176	/**
177	* Append a postfix to the filename BEFORE its file extension
178	*/
179	public postfixFilePath(filePath: string, postfix: string, fileExtensions: string[]) {
180	let parsedPath = path.parse(filePath);	22✔
181
182	if (fileExtensions.includes(parsedPath.ext)) {	22!
183	const regexp = new RegExp(parsedPath.ext + '$', 'i');	22✔
184	return filePath.replace(regexp, postfix + parsedPath.ext);	22✔
185	} else {
186	return filePath;	×
187	}
188	}
189
190	/**
191	* Given a file path, return a new path with the component library postfix removed
192	*/
193	public unPostfixFilePath(filePath: string, postfix: string) {
194	let parts = path.parse(filePath);	9✔
195	const search = `${postfix}${parts.ext}`;	9✔
196	if (filePath.toLowerCase().endsWith(search.toLowerCase())) {	9✔
197	return fileUtils.replaceCaseInsensitive(filePath, search, parts.ext);	6✔
198	} else {
199	return filePath;	3✔
200	}
201	}
202
203	/**
204	* Replace all directory separators with current OS separators,
205	* force all drive letters to lower case (because that's what VSCode does sometimes so this makes it consistent)
206	* @param thePath
207	*/
208	public standardizePath(thePath: string) {
209	if (!thePath) {	1,585✔
210	return thePath;	1✔
211	}
212	let normalizedPath = path.normalize(	1,584✔
213	thePath.replace(/[\/\\]+/g, path.sep)
214	);
215	//force the drive letter to lower case
216	normalizedPath = this.driveLetterToLower(normalizedPath);	1,584✔
217	return normalizedPath;	1,584✔
218	}
219
220	/**
221	* Force the drive letter to lower case
222	* @param fullPath
223	*/
224	public driveLetterToLower(fullPath: string) {
225	if (fullPath) {	1,584!
226	let firstCharCode = fullPath.charCodeAt(0);	1,584✔
227	if (	1,584✔
228	//is upper case A-Z
229	firstCharCode >= 65 && firstCharCode <= 90 &&	3,179✔
230	//next char is colon
231	fullPath[1] === ':'
232	) {
233	fullPath = fullPath[0].toLowerCase() + fullPath.substring(1);	16✔
234	}
235	}
236	return fullPath;	1,584✔
237	}
238
239	/**
240	* Get a file url for a file path (i.e. file:///C:/projects/Something or file:///projects/something
241	* @param fullPath
242	*/
243	public getFileProtocolPath(fullPath: string) {
244	if (fullPath.startsWith('file://')) {	×
245	return fullPath;	×
246	}
247	let result: string;
248	if (fullPath.startsWith('/') \|\| fullPath.startsWith('\\')) {	×
249	result = `file://${fullPath}`;	×
250	} else {
251	result = `file:///${fullPath}`;	×
252	}
253	return result;	×
254	}
255
256	/**
257	* Given a path to a folder, search all files until an entry point is found.
258	* (An entry point is a function that roku uses as the Main function to start the program).
259	* @param projectPath - a path to a Roku project
260	*/
261	public async findEntryPoint(projectPath: string) {
262	let results = {	18✔
263	...await findInFiles.find({ term: 'sub\\s+RunScreenSaver\\s\\(', flags: 'ig' }, projectPath, /.\.brs/),
264	...await findInFiles.find({ term: 'function\\s+RunScreenSaver\\s\\(', flags: 'ig' }, projectPath, /.\.brs/),
265	...await findInFiles.find({ term: 'sub\\s+RunUserInterface\\s\\(', flags: 'ig' }, projectPath, /.\.brs/),
266	...await findInFiles.find({ term: 'function\\s+RunUserInterface\\s\\(', flags: 'ig' }, projectPath, /.\.brs/),
267	...await findInFiles.find({ term: 'sub\\s+main\\s\\(', flags: 'ig' }, projectPath, /.\.brs/),
268	...await findInFiles.find({ term: 'function\\s+main\\s\\(', flags: 'ig' }, projectPath, /.\.brs/)
269	};
270	let keys = Object.keys(results);	18✔
271	if (keys.length === 0) {	18!
272	throw new Error('Unable to find an entry point. Please make sure that you have a RunUserInterface, RunScreenSaver, or Main sub/function declared in your BrightScript project');	×
273	}
274
275	let entryPath = keys[0];	18✔
276
277	let entryLineContents = results[entryPath].line[0];	18✔
278
279	let lineNumber: number;
280	//load the file contents
281	let contents = await fsExtra.readFile(entryPath);	18✔
282	let lines = contents.toString().split(/\r?\n/g);	18✔
283	//loop through the lines until we find the entry line
284	for (let i = 0; i < lines.length; i++) {	18✔
285	let line = lines[i];	26✔
286	if (line.includes(entryLineContents)) {	26✔
287	lineNumber = i + 1;	18✔
288	break;	18✔
289	}
290	}
291	let relativePath = fileUtils.removeLeadingSlash(	18✔
292	rokuDeployUtil.stringReplaceInsensitive(entryPath, projectPath, '')
293	);
294
295	return {	18✔
296	relativePath: relativePath,
297	pathAbsolute: entryPath,
298	contents: entryLineContents,
299	lineNumber: lineNumber
300	};
301	}
302
303	/**
304	* If a string has a leading slash, remove it
305	*/
306	public removeLeadingSlash(thePath: string) {
307	if (typeof thePath === 'string') {	35!
308	while (thePath.startsWith('/') \|\| thePath.startsWith('\\')) {	35✔
309	thePath = thePath.substring(1);	30✔
310	}
311	}
312	return thePath;	35✔
313	}
314
315	/**
316	* If a string has a trailing slash, remove it
317	*/
318	public removeTrailingSlash(thePath: string) {
319	if (typeof thePath === 'string') {	33!
320	while (thePath.endsWith('/') \|\| thePath.endsWith('\\')) {	33✔
321	thePath = thePath.slice(0, -1);	7✔
322	}
323	}
324	return thePath;	33✔
325	}
326	}
327
328	export let fileUtils = new FileUtils();	1✔
329
330	/**
331	* A tagged template literal function for standardizing the path.
332	*/
333	export function standardizePath(stringParts, ...expressions: any[]) {	1✔
334	let result = [];	759✔
335	for (let i = 0; i < stringParts.length; i++) {	759✔
336	result.push(stringParts[i], expressions[i]);	4,022✔
337	}
338	return fileUtils.standardizePath(	759✔
339	result.join('')
340	);
341	}

rokucommunity / roku-debug / #1981

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