8946487465

Committed 04 May 2024 12:26AM UTC coverage: 87.321% (+0.1%) from 87.212%

Build # 8946487465

Build Type

push

github

Committed by

g-arjones

Commit Message

Add missing tests

Run Details

411 of 479 branches covered (85.8%)

Branch coverage included in aggregate %.

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

16 existing lines in 2 files now uncovered.

2089 of 2384 relevant lines covered (87.63%)

110.46 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 {	1✔
8	return str.replace(/([.*+?^=!:${}()\|\[\]\/\\])/g, '\\$1');	1✔
9	}	1✔
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) {	1✔
19	const pattern = escapeStringForRegex(needle);	1✔
20	const re = new RegExp(pattern, 'g');	1✔
21	return str.replace(re, what);	1✔
22	}	1✔
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 {	51✔
41	const normCase: NormalizationSetting = opt ? opt.normCase ? opt.normCase : 'never' : 'never';	51!
42	const normUnicode: NormalizationSetting = opt ? opt.normUnicode ? opt.normUnicode : 'never' : 'never';	51!
43	let norm = path.normalize(p);	51✔
44	while (path.sep !== path.posix.sep && norm.includes(path.sep)) {	51!
45	norm = norm.replace(path.sep, path.posix.sep);	×
46	}	×
47	// Normalize for case an unicode	51✔
48	switch (normCase) {	51✔
49	case 'always':	51!
50	norm = norm.toLocaleLowerCase();	×
51	break;	×
52	case 'platform':	51✔
53	if (process.platform === 'win32' \|\| process.platform === 'darwin') {	51!
54	norm = norm.toLocaleLowerCase();	×
55	}	×
56	break;	51✔
57	case 'never':	51!
58	break;	×
59	}	51✔
60	switch (normUnicode) {	51✔
61	case 'always':	51!
62	norm = norm.normalize();	×
63	break;	×
64	case 'platform':	51✔
65	if (process.platform === 'darwin') {	51!
66	norm = norm.normalize();	×
67	}	×
68	break;	51✔
69	case 'never':	51!
70	break;	×
71	}	51✔
72	// Remove trailing slashes	51✔
73	norm = norm.replace(/\/$/g, '');	51✔
74	// Remove duplicate slashes	51✔
75	while (norm.includes('//')) {	51!
76	norm = replaceAll(norm, '//', '/');	×
77	}	×
78	return norm;	51✔
79	}	51✔
80		1✔
81	export function platformNormalizePath(p: string): string {	51✔
82	return normalizePath(p, { normCase: 'platform', normUnicode: 'platform' });	51✔
83	}	51✔
84		1✔
85	export function* flatMap<In, Out>(rng: Iterable<In>, fn: (item: In) => Iterable<Out>): Iterable<Out> {	3✔
86	for (const elem of rng) {	3✔
87	const mapped = fn(elem);	67✔
88	for (const other_elem of mapped) {	67✔
89	yield other_elem;	67✔
90	}	67✔
91	}	67✔
92	}	3✔
93		1✔
94	export function dropNulls<T>(items: (T \| null \| undefined)[]): T[] {	1✔
95	return items.filter(item => (item !== null && item !== undefined)) as T[];	1✔
96	}	1✔
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 / 8946487465

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