4395841771

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/mrodrig/doc-path/commit/<a class=hub.com/mrodrig/doc-path/commit/812813f6739f7c1e10b54bc83a8f798277c0bf63">812813f67<a href="https://github.com/mrodrig/doc-path/commit/812813f6739f7c1e10b54bc83a8f798277c0bf63">">Merge </a><a class="double-link" href="https://github.com/mrodrig/doc-path/commit/<a class="double-link" href="https://github.com/mrodrig/doc-path/commit/7e951b3cd28e417d194589810e42f81986090407">7e951b3cd</a>">7e951b3cd</a><a href="https://github.com/mrodrig/doc-path/commit/812813f6739f7c1e10b54bc83a8f798277c0bf63"> into fe67410a6">fe67410a6</a>

Pull Request Pull Request #32: Migrate to TypeScript

Run Details

64 of 65 branches covered (98.46%)

Branch coverage included in aggregate %.

44 of 45 new or added lines in 1 file covered. (97.78%)

44 of 45 relevant lines covered (97.78%)

186.2 hits per line

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

98.18

/src/path.ts

/**
 * @license MIT
 * doc-path <https://github.com/mrodrig/doc-path>
 * Copyright (c) 2015-present, Michael Rodrigues.
 */
'use strict';

/**
 * Main function that evaluates the path in a particular object
 * @throws {Error} possible error if call stack size is exceeded
 */
export function evaluatePath(obj: unknown, kp: string): unknown {
    if (typeof obj !== 'object' || obj === null || !obj) {
        return null;
    }

    const {dotIndex, key, remaining} = state(kp);
    const kpVal = typeof obj === 'object' && kp in obj ? (obj as Record<string, unknown>)[kp] : null;
    const keyVal = key in obj ? (obj as Record<string, unknown>)[key] : null;

    // If there is a '.' in the key path and the key path doesn't appear in the object, recur on the subobject
    if (dotIndex >= 0 && typeof obj === 'object' && !(kp in obj)) {
        // If there's an array at the current key in the object, then iterate over those items evaluating the remaining path
        if (Array.isArray(keyVal)) {
            return keyVal.map((doc: unknown) => evaluatePath(doc, remaining));
        }
        // Otherwise, we can just recur
        return evaluatePath(keyVal, remaining);
    } else if (Array.isArray(obj)) {
        // If this object is actually an array, then iterate over those items evaluating the path
        return obj.map((doc) => evaluatePath(doc, kp));
    } else if (dotIndex >= 0 && kp !== key && typeof obj === 'object' && key in obj) {
    // If there's a field with a non-nested dot, then recur into that sub-value
        return evaluatePath(keyVal, remaining);
    } else if (dotIndex === -1 && typeof obj === 'object' && key in obj && !(kp in obj)) {
        // If the field is here, but the key was escaped
        return keyVal;
    }

    // Otherwise, we can just return value directly
    return kpVal;
}

/**
 * Main function that performs validation before passing off to _sp
 * @throws {Error} possible error if call stack size is exceeded
 */
export function setPath<T>(obj: T, kp: string, v: unknown): T {
    if (!obj) {
        throw new Error('No object was provided.');
    } else if (!kp) {
        throw new Error('No keyPath was provided.');
    }

    return _sp(obj, kp, v);
}

// Helper function that will set the value in the provided object/array.
function _sp<T>(obj: T, kp: string, v: unknown): T {
    const {dotIndex, key, remaining} = state(kp);

    // If this is clearly a prototype pollution attempt, then refuse to modify the path
    if (kp.startsWith('__proto__') || kp.startsWith('constructor') || kp.startsWith('prototype')) {
        return obj;
    }

    if (dotIndex >= 0) {
        // If there is a '.' in the key path, recur on the subdoc and ...
        if (typeof obj === 'object' && obj !== null && !(key in obj) && Array.isArray(obj)) {
            // If this is an array and there are multiple levels of keys to iterate over, recur.
            obj.forEach((doc) => _sp(doc, kp, v));
            return obj;
        } else if (typeof obj === 'object' && obj !== null && !(key in obj) && !Array.isArray(obj)) {
            // If the current key doesn't exist yet, populate it
            (obj as Record<string, unknown>)[key] = {};
        }
        _sp((obj as Record<string, unknown>)[key], remaining, v);
    } else if (Array.isArray(obj)) {
        // If this "obj" is actually an array, then we can loop over each of the values and set the path
        obj.forEach((doc) => _sp(doc, remaining, v));
        return obj;
    } else {
        // Otherwise, we can set the path directly
        (obj as Record<string, unknown>)[key] = v;
    }

    return obj;
}

// Helper function that returns some information necessary to evaluate or set a path  based on the provided keyPath value
function state(kp: string): PathState {
    const dotIndex = findFirstNonEscapedDotIndex(kp);
    return {
        dotIndex,
        key: kp.slice(0, dotIndex >= 0 ? dotIndex : undefined).replace(/\\./g, '.'),
        remaining: kp.slice(dotIndex + 1)
    };
}

function findFirstNonEscapedDotIndex(kp: string) {
    for (let i = 0; i < kp.length; i++) {
        const previousChar = i > 0 ? kp[i - 1] : '',
            currentChar = kp[i];
        if (currentChar === '.' && previousChar !== '\\') return i;
    }
    return -1;
}

interface PathState {
    dotIndex: number;
    key: string;
    remaining: string;
}

1	/**
2	* @license MIT
3	* doc-path <https://github.com/mrodrig/doc-path>
4	* Copyright (c) 2015-present, Michael Rodrigues.
5	*/
6	'use strict';
7
8	/**
9	* Main function that evaluates the path in a particular object
10	* @throws {Error} possible error if call stack size is exceeded
11	*/
12	export function evaluatePath(obj: unknown, kp: string): unknown {	3✔
13	if (typeof obj !== 'object' \|\| obj === null \|\| !obj) {	123✔
14	return null;	6✔
15	}
16
17	const {dotIndex, key, remaining} = state(kp);	117✔
18	const kpVal = typeof obj === 'object' && kp in obj ? (obj as Record<string, unknown>)[kp] : null;	117✔
19	const keyVal = key in obj ? (obj as Record<string, unknown>)[key] : null;	117✔
20
21	// If there is a '.' in the key path and the key path doesn't appear in the object, recur on the subobject
22	if (dotIndex >= 0 && typeof obj === 'object' && !(kp in obj)) {	117✔
23	// If there's an array at the current key in the object, then iterate over those items evaluating the remaining path
24	if (Array.isArray(keyVal)) {	33✔
25	return keyVal.map((doc: unknown) => evaluatePath(doc, remaining));	27✔
26	}
27	// Otherwise, we can just recur
28	return evaluatePath(keyVal, remaining);	21✔
29	} else if (Array.isArray(obj)) {	84✔
30	// If this object is actually an array, then iterate over those items evaluating the path
31	return obj.map((doc) => evaluatePath(doc, kp));	6✔
32	} else if (dotIndex >= 0 && kp !== key && typeof obj === 'object' && key in obj) {	81✔
33	// If there's a field with a non-nested dot, then recur into that sub-value
34	return evaluatePath(keyVal, remaining);	6✔
35	} else if (dotIndex === -1 && typeof obj === 'object' && key in obj && !(kp in obj)) {	75✔
36	// If the field is here, but the key was escaped
37	return keyVal;	15✔
38	}
39
40	// Otherwise, we can just return value directly
41	return kpVal;	60✔
42	}
43
44	/**
45	* Main function that performs validation before passing off to _sp
46	* @throws {Error} possible error if call stack size is exceeded
47	*/
48	export function setPath<T>(obj: T, kp: string, v: unknown): T {	3✔
49	if (!obj) {	72✔
50	throw new Error('No object was provided.');	6✔
51	} else if (!kp) {	66!
NEW 52	throw new Error('No keyPath was provided.');	×
53	}
54
55	return _sp(obj, kp, v);	66✔
56	}
57
58	// Helper function that will set the value in the provided object/array.
59	function _sp<T>(obj: T, kp: string, v: unknown): T {
60	const {dotIndex, key, remaining} = state(kp);	144✔
61
62	// If this is clearly a prototype pollution attempt, then refuse to modify the path
63	if (kp.startsWith('__proto__') \|\| kp.startsWith('constructor') \|\| kp.startsWith('prototype')) {	144✔
64	return obj;	21✔
65	}
66
67	if (dotIndex >= 0) {	123✔
68	// If there is a '.' in the key path, recur on the subdoc and ...
69	if (typeof obj === 'object' && obj !== null && !(key in obj) && Array.isArray(obj)) {	57✔
70	// If this is an array and there are multiple levels of keys to iterate over, recur.
71	obj.forEach((doc) => _sp(doc, kp, v));	6✔
72	return obj;	3✔
73	} else if (typeof obj === 'object' && obj !== null && !(key in obj) && !Array.isArray(obj)) {	54✔
74	// If the current key doesn't exist yet, populate it
75	(obj as Record<string, unknown>)[key] = {};	15✔
76	}
77	_sp((obj as Record<string, unknown>)[key], remaining, v);	54✔
78	} else if (Array.isArray(obj)) {	66✔
79	// If this "obj" is actually an array, then we can loop over each of the values and set the path
80	obj.forEach((doc) => _sp(doc, remaining, v));	18✔
81	return obj;	9✔
82	} else {
83	// Otherwise, we can set the path directly
84	(obj as Record<string, unknown>)[key] = v;	57✔
85	}
86
87	return obj;	111✔
88	}
89
90	// Helper function that returns some information necessary to evaluate or set a path based on the provided keyPath value
91	function state(kp: string): PathState {
92	const dotIndex = findFirstNonEscapedDotIndex(kp);	261✔
93	return {	261✔
94	dotIndex,
95	key: kp.slice(0, dotIndex >= 0 ? dotIndex : undefined).replace(/\\./g, '.'),	261✔
96	remaining: kp.slice(dotIndex + 1)
97	};
98	}
99
100	function findFirstNonEscapedDotIndex(kp: string) {
101	for (let i = 0; i < kp.length; i++) {	261✔
102	const previousChar = i > 0 ? kp[i - 1] : '',	1,785✔
103	currentChar = kp[i];	1,785✔
104	if (currentChar === '.' && previousChar !== '\\') return i;	1,785✔
105	}
106	return -1;	138✔
107	}
108
109	interface PathState {
110	dotIndex: number;
111	key: string;
112	remaining: string;
113	}

mrodrig / doc-path / 4395841771

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