8952888435

Committed 04 May 2024 07:56PM UTC coverage: 88.113% (+0.5%) from 87.618%

Build # 8952888435

Build Type

push

github

Committed by

g-arjones

Commit Message

Add missing tests

Run Details

433 of 496 branches covered (87.3%)

Branch coverage included in aggregate %.

19 of 19 new or added lines in 2 files covered. (100.0%)

9 existing lines in 2 files now uncovered.

2102 of 2381 relevant lines covered (88.28%)

234.47 hits per line

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

74.24

/src/cmt/util.ts

import * as path from 'path';


/**
 * Escape a string so it can be used as a regular expression
 */
export function escapeStringForRegex(str: string): string {
    return str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1');
}

/**
 * Replace all occurrences of `needle` in `str` with `what`
 * @param str The input string
 * @param needle The search string
 * @param what The value to insert in place of `needle`
 * @returns The modified string
 */
export function replaceAll(str: string, needle: string, what: string) {
    const pattern = escapeStringForRegex(needle);
    const re = new RegExp(pattern, 'g');
    return str.replace(re, what);
}

type NormalizationSetting = 'always' | 'never' | 'platform';
interface PathNormalizationOptions {
    normCase?: NormalizationSetting;
    normUnicode?: NormalizationSetting;
}

/**
 * Completely normalize/canonicalize a path.
 * Using `path.normalize` isn't sufficient. We want convert all paths to use
 * POSIX separators, remove redundant separators, and sometimes normalize the
 * case of the path.
 *
 * @param p The input path
 * @param opt Options to control the normalization
 * @returns The normalized path
 */
export function normalizePath(p: string, opt: PathNormalizationOptions): string {
    const normCase: NormalizationSetting = opt ? opt.normCase ? opt.normCase : 'never' : 'never';
    const normUnicode: NormalizationSetting = opt ? opt.normUnicode ? opt.normUnicode : 'never' : 'never';
    let norm = path.normalize(p);
    while (path.sep !== path.posix.sep && norm.includes(path.sep)) {
        norm = norm.replace(path.sep, path.posix.sep);
    }
    // Normalize for case an unicode
    switch (normCase) {
        case 'always':
            norm = norm.toLocaleLowerCase();
            break;
        case 'platform':
            if (process.platform === 'win32' || process.platform === 'darwin') {
                norm = norm.toLocaleLowerCase();
            }
            break;
        case 'never':
            break;
    }
    switch (normUnicode) {
        case 'always':
            norm = norm.normalize();
            break;
        case 'platform':
            if (process.platform === 'darwin') {
                norm = norm.normalize();
            }
            break;
        case 'never':
            break;
    }
    // Remove trailing slashes
    norm = norm.replace(/\/$/g, '');
    // Remove duplicate slashes
    while (norm.includes('//')) {
        norm = replaceAll(norm, '//', '/');
    }
    return norm;
}

export function platformNormalizePath(p: string): string {
    return normalizePath(p, { normCase: 'platform', normUnicode: 'platform' });
}

export function* flatMap<In, Out>(rng: Iterable<In>, fn: (item: In) => Iterable<Out>): Iterable<Out> {
    for (const elem of rng) {
        const mapped = fn(elem);
        for (const other_elem of mapped) {
            yield other_elem;
        }
    }
}

export function dropNulls<T>(items: (T | null | undefined)[]): T[] {
    return items.filter(item => (item !== null && item !== undefined)) as T[];
}

export enum Ordering {
    Greater,
    Equivalent,
    Less,
}

export function errorToString(e: any): string {
    if (e.stack) {
        // e.stack has both the message and the stack in it.
        return `\n\t${e.stack}`;
    }
    return `\n\t${e.toString()}`;
}

1	import * as path from 'path';	1✔
2		1✔
3		1✔
4	/**	1✔
5	* Escape a string so it can be used as a regular expression	1✔
6	*/	1✔
7	export function escapeStringForRegex(str: string): string {	7✔
8	return str.replace(/([.*+?^=!:${}()\|\[\]\/\\])/g, '\\$1');	7✔
9	}	7✔
10		1✔
11	/**	1✔
12	* Replace all occurrences of `needle` in `str` with `what`	1✔
13	* @param str The input string	1✔
14	* @param needle The search string	1✔
15	* @param what The value to insert in place of `needle`	1✔
16	* @returns The modified string	1✔
17	*/	1✔
18	export function replaceAll(str: string, needle: string, what: string) {	7✔
19	const pattern = escapeStringForRegex(needle);	7✔
20	const re = new RegExp(pattern, 'g');	7✔
21	return str.replace(re, what);	7✔
22	}	7✔
23		1✔
24	type NormalizationSetting = 'always' \| 'never' \| 'platform';	1✔
25	interface PathNormalizationOptions {	1✔
26	normCase?: NormalizationSetting;	1✔
27	normUnicode?: NormalizationSetting;	1✔
28	}	1✔
29		1✔
30	/**	1✔
31	* Completely normalize/canonicalize a path.	1✔
32	* Using `path.normalize` isn't sufficient. We want convert all paths to use	1✔
33	* POSIX separators, remove redundant separators, and sometimes normalize the	1✔
34	* case of the path.	1✔
35	*	1✔
36	* @param p The input path	1✔
37	* @param opt Options to control the normalization	1✔
38	* @returns The normalized path	1✔
39	*/	1✔
40	export function normalizePath(p: string, opt: PathNormalizationOptions): string {	102✔
41	const normCase: NormalizationSetting = opt ? opt.normCase ? opt.normCase : 'never' : 'never';	102!
42	const normUnicode: NormalizationSetting = opt ? opt.normUnicode ? opt.normUnicode : 'never' : 'never';	102!
43	let norm = path.normalize(p);	102✔
44	while (path.sep !== path.posix.sep && norm.includes(path.sep)) {	102!
45	norm = norm.replace(path.sep, path.posix.sep);	×
46	}	×
47	// Normalize for case an unicode	102✔
48	switch (normCase) {	102✔
49	case 'always':	102!
50	norm = norm.toLocaleLowerCase();	×
51	break;	×
52	case 'platform':	102✔
53	if (process.platform === 'win32' \|\| process.platform === 'darwin') {	102!
54	norm = norm.toLocaleLowerCase();	×
55	}	×
56	break;	102✔
57	case 'never':	102!
58	break;	×
59	}	102✔
60	switch (normUnicode) {	102✔
61	case 'always':	102!
62	norm = norm.normalize();	×
63	break;	×
64	case 'platform':	102✔
65	if (process.platform === 'darwin') {	102!
66	norm = norm.normalize();	×
67	}	×
68	break;	102✔
69	case 'never':	102!
70	break;	×
71	}	102✔
72	// Remove trailing slashes	102✔
73	norm = norm.replace(/\/$/g, '');	102✔
74	// Remove duplicate slashes	102✔
75	while (norm.includes('//')) {	102!
76	norm = replaceAll(norm, '//', '/');	×
77	}	×
78	return norm;	102✔
79	}	102✔
80		1✔
81	export function platformNormalizePath(p: string): string {	102✔
82	return normalizePath(p, { normCase: 'platform', normUnicode: 'platform' });	102✔
83	}	102✔
84		1✔
85	export function* flatMap<In, Out>(rng: Iterable<In>, fn: (item: In) => Iterable<Out>): Iterable<Out> {	6✔
86	for (const elem of rng) {	6✔
87	const mapped = fn(elem);	134✔
88	for (const other_elem of mapped) {	134✔
89	yield other_elem;	134✔
90	}	134✔
91	}	134✔
92	}	6✔
93		1✔
94	export function dropNulls<T>(items: (T \| null \| undefined)[]): T[] {	2✔
95	return items.filter(item => (item !== null && item !== undefined)) as T[];	2✔
96	}	2✔
97		1✔
98	export enum Ordering {	1✔
99	Greater,	1✔
100	Equivalent,	1✔
101	Less,	1✔
102	}	1✔
103		1✔
UNCOV 104	export function errorToString(e: any): string {	×
UNCOV 105	if (e.stack) {	×
UNCOV 106	// e.stack has both the message and the stack in it.	×
UNCOV 107	return `\n\t${e.stack}`;	×
UNCOV 108	}	×
UNCOV 109	return `\n\t${e.toString()}`;	×
UNCOV 110	}	×

g-arjones / vscode-autoproj / 8952888435

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