From 2d58da520fffaeaee1bceeb33b6e3dc339ea68a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9C=A8=E6=9D=89?= Date: Wed, 19 Dec 2018 10:29:39 +0800 Subject: [PATCH] migrate deno_path to deno_std (denoland/deno_std#26) Previously https://github.com/zhmushan/deno_path Original: https://github.com/denoland/deno_std/commit/1a35f9daf5aa1c10c61d62cccbe7f9ae3c615a0e --- LICENSE | 21 + net/bufio_test.ts | 4 +- path/README.md | 7 + path/basename_test.ts | 75 ++ path/constants.ts | 53 ++ path/dirname_test.ts | 61 ++ path/extname_test.ts | 89 ++ path/index.ts | 1425 ++++++++++++++++++++++++++++++ path/interface.ts | 47 + path/isabsolute_test.ts | 33 + path/join_test.ts | 124 +++ path/parse_format_test.ts | 176 ++++ path/relative_test.ts | 72 ++ path/resolve_test.ts | 49 + path/zero_length_strings_test.ts | 46 + test.ts | 13 +- 16 files changed, 2292 insertions(+), 3 deletions(-) create mode 100644 LICENSE create mode 100644 path/README.md create mode 100644 path/basename_test.ts create mode 100644 path/constants.ts create mode 100644 path/dirname_test.ts create mode 100644 path/extname_test.ts create mode 100644 path/index.ts create mode 100644 path/interface.ts create mode 100644 path/isabsolute_test.ts create mode 100644 path/join_test.ts create mode 100644 path/parse_format_test.ts create mode 100644 path/relative_test.ts create mode 100644 path/resolve_test.ts create mode 100644 path/zero_length_strings_test.ts diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000..0270530e31 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright 2018 the Deno authors. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/net/bufio_test.ts b/net/bufio_test.ts index 19954bdf6e..96490a6c9d 100644 --- a/net/bufio_test.ts +++ b/net/bufio_test.ts @@ -108,7 +108,7 @@ test(async function bufioBufReader() { for (let i = 0; i < texts.length - 1; i++) { texts[i] = str + "\n"; all += texts[i]; - str += String.fromCharCode(i % 26 + 97); + str += String.fromCharCode((i % 26) + 97); } texts[texts.length - 1] = all; @@ -293,7 +293,7 @@ test(async function bufioWriter() { const data = new Uint8Array(8192); for (let i = 0; i < data.byteLength; i++) { - data[i] = charCode(" ") + i % (charCode("~") - charCode(" ")); + data[i] = charCode(" ") + (i % (charCode("~") - charCode(" "))); } const w = new Buffer(); diff --git a/path/README.md b/path/README.md new file mode 100644 index 0000000000..d4f693577f --- /dev/null +++ b/path/README.md @@ -0,0 +1,7 @@ +# Deno Path Manipulation Libraries + +Usage: + +```ts +import * as path from 'https://deno.land/x/path/index.ts' +``` diff --git a/path/basename_test.ts b/path/basename_test.ts new file mode 100644 index 0000000000..9e051fbcd9 --- /dev/null +++ b/path/basename_test.ts @@ -0,0 +1,75 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +test(function basename() { + assertEqual(path.basename(".js", ".js"), ""); + assertEqual(path.basename(""), ""); + assertEqual(path.basename("/dir/basename.ext"), "basename.ext"); + assertEqual(path.basename("/basename.ext"), "basename.ext"); + assertEqual(path.basename("basename.ext"), "basename.ext"); + assertEqual(path.basename("basename.ext/"), "basename.ext"); + assertEqual(path.basename("basename.ext//"), "basename.ext"); + assertEqual(path.basename("aaa/bbb", "/bbb"), "bbb"); + assertEqual(path.basename("aaa/bbb", "a/bbb"), "bbb"); + assertEqual(path.basename("aaa/bbb", "bbb"), "bbb"); + assertEqual(path.basename("aaa/bbb//", "bbb"), "bbb"); + assertEqual(path.basename("aaa/bbb", "bb"), "b"); + assertEqual(path.basename("aaa/bbb", "b"), "bb"); + assertEqual(path.basename("/aaa/bbb", "/bbb"), "bbb"); + assertEqual(path.basename("/aaa/bbb", "a/bbb"), "bbb"); + assertEqual(path.basename("/aaa/bbb", "bbb"), "bbb"); + assertEqual(path.basename("/aaa/bbb//", "bbb"), "bbb"); + assertEqual(path.basename("/aaa/bbb", "bb"), "b"); + assertEqual(path.basename("/aaa/bbb", "b"), "bb"); + assertEqual(path.basename("/aaa/bbb"), "bbb"); + assertEqual(path.basename("/aaa/"), "aaa"); + assertEqual(path.basename("/aaa/b"), "b"); + assertEqual(path.basename("/a/b"), "b"); + assertEqual(path.basename("//a"), "a"); + + // On unix a backslash is just treated as any other character. + assertEqual( + path.posix.basename("\\dir\\basename.ext"), + "\\dir\\basename.ext" + ); + assertEqual(path.posix.basename("\\basename.ext"), "\\basename.ext"); + assertEqual(path.posix.basename("basename.ext"), "basename.ext"); + assertEqual(path.posix.basename("basename.ext\\"), "basename.ext\\"); + assertEqual(path.posix.basename("basename.ext\\\\"), "basename.ext\\\\"); + assertEqual(path.posix.basename("foo"), "foo"); + + // POSIX filenames may include control characters + const controlCharFilename = "Icon" + String.fromCharCode(13); + assertEqual( + path.posix.basename("/a/b/" + controlCharFilename), + controlCharFilename + ); +}); + +test(function basenameWin32() { + assertEqual(path.win32.basename("\\dir\\basename.ext"), "basename.ext"); + assertEqual(path.win32.basename("\\basename.ext"), "basename.ext"); + assertEqual(path.win32.basename("basename.ext"), "basename.ext"); + assertEqual(path.win32.basename("basename.ext\\"), "basename.ext"); + assertEqual(path.win32.basename("basename.ext\\\\"), "basename.ext"); + assertEqual(path.win32.basename("foo"), "foo"); + assertEqual(path.win32.basename("aaa\\bbb", "\\bbb"), "bbb"); + assertEqual(path.win32.basename("aaa\\bbb", "a\\bbb"), "bbb"); + assertEqual(path.win32.basename("aaa\\bbb", "bbb"), "bbb"); + assertEqual(path.win32.basename("aaa\\bbb\\\\\\\\", "bbb"), "bbb"); + assertEqual(path.win32.basename("aaa\\bbb", "bb"), "b"); + assertEqual(path.win32.basename("aaa\\bbb", "b"), "bb"); + assertEqual(path.win32.basename("C:"), ""); + assertEqual(path.win32.basename("C:."), "."); + assertEqual(path.win32.basename("C:\\"), ""); + assertEqual(path.win32.basename("C:\\dir\\base.ext"), "base.ext"); + assertEqual(path.win32.basename("C:\\basename.ext"), "basename.ext"); + assertEqual(path.win32.basename("C:basename.ext"), "basename.ext"); + assertEqual(path.win32.basename("C:basename.ext\\"), "basename.ext"); + assertEqual(path.win32.basename("C:basename.ext\\\\"), "basename.ext"); + assertEqual(path.win32.basename("C:foo"), "foo"); + assertEqual(path.win32.basename("file:stream"), "file:stream"); +}); diff --git a/path/constants.ts b/path/constants.ts new file mode 100644 index 0000000000..b440be9cca --- /dev/null +++ b/path/constants.ts @@ -0,0 +1,53 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { platform } from "deno"; + +const isWindows = platform.os === "win"; + +// Alphabet chars. +export const CHAR_UPPERCASE_A = 65; /* A */ +export const CHAR_LOWERCASE_A = 97; /* a */ +export const CHAR_UPPERCASE_Z = 90; /* Z */ +export const CHAR_LOWERCASE_Z = 122; /* z */ + +// Non-alphabetic chars. +export const CHAR_DOT = 46; /* . */ +export const CHAR_FORWARD_SLASH = 47; /* / */ +export const CHAR_BACKWARD_SLASH = 92; /* \ */ +export const CHAR_VERTICAL_LINE = 124; /* | */ +export const CHAR_COLON = 58; /* : */ +export const CHAR_QUESTION_MARK = 63; /* ? */ +export const CHAR_UNDERSCORE = 95; /* _ */ +export const CHAR_LINE_FEED = 10; /* \n */ +export const CHAR_CARRIAGE_RETURN = 13; /* \r */ +export const CHAR_TAB = 9; /* \t */ +export const CHAR_FORM_FEED = 12; /* \f */ +export const CHAR_EXCLAMATION_MARK = 33; /* ! */ +export const CHAR_HASH = 35; /* # */ +export const CHAR_SPACE = 32; /* */ +export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */ +export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */ +export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */ +export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */ +export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */ +export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */ +export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */ +export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */ +export const CHAR_HYPHEN_MINUS = 45; /* - */ +export const CHAR_PLUS = 43; /* + */ +export const CHAR_DOUBLE_QUOTE = 34; /* " */ +export const CHAR_SINGLE_QUOTE = 39; /* ' */ +export const CHAR_PERCENT = 37; /* % */ +export const CHAR_SEMICOLON = 59; /* ; */ +export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */ +export const CHAR_GRAVE_ACCENT = 96; /* ` */ +export const CHAR_AT = 64; /* @ */ +export const CHAR_AMPERSAND = 38; /* & */ +export const CHAR_EQUAL = 61; /* = */ + +// Digits +export const CHAR_0 = 48; /* 0 */ +export const CHAR_9 = 57; /* 9 */ + +export const EOL = isWindows ? "\r\n" : "\n"; diff --git a/path/dirname_test.ts b/path/dirname_test.ts new file mode 100644 index 0000000000..12fa58743e --- /dev/null +++ b/path/dirname_test.ts @@ -0,0 +1,61 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +test(function dirname() { + assertEqual(path.posix.dirname("/a/b/"), "/a"); + assertEqual(path.posix.dirname("/a/b"), "/a"); + assertEqual(path.posix.dirname("/a"), "/"); + assertEqual(path.posix.dirname(""), "."); + assertEqual(path.posix.dirname("/"), "/"); + assertEqual(path.posix.dirname("////"), "/"); + assertEqual(path.posix.dirname("//a"), "//"); + assertEqual(path.posix.dirname("foo"), "."); +}); + +test(function dirnameWin32() { + assertEqual(path.win32.dirname("c:\\"), "c:\\"); + assertEqual(path.win32.dirname("c:\\foo"), "c:\\"); + assertEqual(path.win32.dirname("c:\\foo\\"), "c:\\"); + assertEqual(path.win32.dirname("c:\\foo\\bar"), "c:\\foo"); + assertEqual(path.win32.dirname("c:\\foo\\bar\\"), "c:\\foo"); + assertEqual(path.win32.dirname("c:\\foo\\bar\\baz"), "c:\\foo\\bar"); + assertEqual(path.win32.dirname("\\"), "\\"); + assertEqual(path.win32.dirname("\\foo"), "\\"); + assertEqual(path.win32.dirname("\\foo\\"), "\\"); + assertEqual(path.win32.dirname("\\foo\\bar"), "\\foo"); + assertEqual(path.win32.dirname("\\foo\\bar\\"), "\\foo"); + assertEqual(path.win32.dirname("\\foo\\bar\\baz"), "\\foo\\bar"); + assertEqual(path.win32.dirname("c:"), "c:"); + assertEqual(path.win32.dirname("c:foo"), "c:"); + assertEqual(path.win32.dirname("c:foo\\"), "c:"); + assertEqual(path.win32.dirname("c:foo\\bar"), "c:foo"); + assertEqual(path.win32.dirname("c:foo\\bar\\"), "c:foo"); + assertEqual(path.win32.dirname("c:foo\\bar\\baz"), "c:foo\\bar"); + assertEqual(path.win32.dirname("file:stream"), "."); + assertEqual(path.win32.dirname("dir\\file:stream"), "dir"); + assertEqual(path.win32.dirname("\\\\unc\\share"), "\\\\unc\\share"); + assertEqual(path.win32.dirname("\\\\unc\\share\\foo"), "\\\\unc\\share\\"); + assertEqual(path.win32.dirname("\\\\unc\\share\\foo\\"), "\\\\unc\\share\\"); + assertEqual( + path.win32.dirname("\\\\unc\\share\\foo\\bar"), + "\\\\unc\\share\\foo" + ); + assertEqual( + path.win32.dirname("\\\\unc\\share\\foo\\bar\\"), + "\\\\unc\\share\\foo" + ); + assertEqual( + path.win32.dirname("\\\\unc\\share\\foo\\bar\\baz"), + "\\\\unc\\share\\foo\\bar" + ); + assertEqual(path.win32.dirname("/a/b/"), "/a"); + assertEqual(path.win32.dirname("/a/b"), "/a"); + assertEqual(path.win32.dirname("/a"), "/"); + assertEqual(path.win32.dirname(""), "."); + assertEqual(path.win32.dirname("/"), "/"); + assertEqual(path.win32.dirname("////"), "/"); + assertEqual(path.win32.dirname("foo"), "."); +}); diff --git a/path/extname_test.ts b/path/extname_test.ts new file mode 100644 index 0000000000..f9a44a8123 --- /dev/null +++ b/path/extname_test.ts @@ -0,0 +1,89 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +const slashRE = /\//g; + +const pairs = [ + ["", ""], + ["/path/to/file", ""], + ["/path/to/file.ext", ".ext"], + ["/path.to/file.ext", ".ext"], + ["/path.to/file", ""], + ["/path.to/.file", ""], + ["/path.to/.file.ext", ".ext"], + ["/path/to/f.ext", ".ext"], + ["/path/to/..ext", ".ext"], + ["/path/to/..", ""], + ["file", ""], + ["file.ext", ".ext"], + [".file", ""], + [".file.ext", ".ext"], + ["/file", ""], + ["/file.ext", ".ext"], + ["/.file", ""], + ["/.file.ext", ".ext"], + [".path/file.ext", ".ext"], + ["file.ext.ext", ".ext"], + ["file.", "."], + [".", ""], + ["./", ""], + [".file.ext", ".ext"], + [".file", ""], + [".file.", "."], + [".file..", "."], + ["..", ""], + ["../", ""], + ["..file.ext", ".ext"], + ["..file", ".file"], + ["..file.", "."], + ["..file..", "."], + ["...", "."], + ["...ext", ".ext"], + ["....", "."], + ["file.ext/", ".ext"], + ["file.ext//", ".ext"], + ["file/", ""], + ["file//", ""], + ["file./", "."], + ["file.//", "."] +]; + +test(function extname() { + pairs.forEach(function(p) { + const input = p[0]; + const expected = p[1]; + assertEqual(expected, path.posix.extname(input)); + }); + + // On *nix, backslash is a valid name component like any other character. + assertEqual(path.posix.extname(".\\"), ""); + assertEqual(path.posix.extname("..\\"), ".\\"); + assertEqual(path.posix.extname("file.ext\\"), ".ext\\"); + assertEqual(path.posix.extname("file.ext\\\\"), ".ext\\\\"); + assertEqual(path.posix.extname("file\\"), ""); + assertEqual(path.posix.extname("file\\\\"), ""); + assertEqual(path.posix.extname("file.\\"), ".\\"); + assertEqual(path.posix.extname("file.\\\\"), ".\\\\"); +}); + +test(function extnameWin32() { + pairs.forEach(function(p) { + const input = p[0].replace(slashRE, "\\"); + const expected = p[1]; + assertEqual(expected, path.win32.extname(input)); + assertEqual(expected, path.win32.extname("C:" + input)); + }); + + // On Windows, backslash is a path separator. + assertEqual(path.win32.extname(".\\"), ""); + assertEqual(path.win32.extname("..\\"), ""); + assertEqual(path.win32.extname("file.ext\\"), ".ext"); + assertEqual(path.win32.extname("file.ext\\\\"), ".ext"); + assertEqual(path.win32.extname("file\\"), ""); + assertEqual(path.win32.extname("file\\\\"), ""); + assertEqual(path.win32.extname("file.\\"), "."); + assertEqual(path.win32.extname("file.\\\\"), "."); +}); diff --git a/path/index.ts b/path/index.ts new file mode 100644 index 0000000000..3b59bffa78 --- /dev/null +++ b/path/index.ts @@ -0,0 +1,1425 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { + CHAR_UPPERCASE_A, + CHAR_LOWERCASE_A, + CHAR_UPPERCASE_Z, + CHAR_LOWERCASE_Z, + CHAR_DOT, + CHAR_FORWARD_SLASH, + CHAR_BACKWARD_SLASH, + CHAR_COLON, + CHAR_QUESTION_MARK +} from "./constants"; +import { cwd, env, platform } from "deno"; +import { FormatInputPathObject, ParsedPath } from "./interface"; + +function assertPath(path: string) { + if (typeof path !== "string") { + throw new TypeError( + `Path must be a string. Received ${JSON.stringify(path)}` + ); + } +} + +function isPathSeparator(code: number) { + return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH; +} + +function isPosixPathSeparator(code: number) { + return code === CHAR_FORWARD_SLASH; +} + +function isWindowsDeviceRoot(code: number) { + return ( + (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) || + (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) + ); +} + +// Resolves . and .. elements in a path with directory names +function normalizeString( + path: string, + allowAboveRoot: boolean, + separator: string, + isPathSeparator: (code: number) => boolean +) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code: number; + for (let i = 0; i <= path.length; ++i) { + if (i < path.length) code = path.charCodeAt(i); + else if (isPathSeparator(code)) break; + else code = CHAR_FORWARD_SLASH; + + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) { + // NOOP + } else if (lastSlash !== i - 1 && dots === 2) { + if ( + res.length < 2 || + lastSegmentLength !== 2 || + res.charCodeAt(res.length - 1) !== CHAR_DOT || + res.charCodeAt(res.length - 2) !== CHAR_DOT + ) { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf(separator); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) res += `${separator}..`; + else res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) res += separator + path.slice(lastSlash + 1, i); + else res = path.slice(lastSlash + 1, i); + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } else if (code === CHAR_DOT && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} + +function _format(sep: string, pathObject: FormatInputPathObject) { + const dir = pathObject.dir || pathObject.root; + const base = + pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) { + return base; + } + if (dir === pathObject.root) { + return dir + base; + } + return dir + sep + base; +} + +const win32 = { + // path.resolve([from ...], to) + resolve: function resolve(...pathSegments: string[]) { + let resolvedDevice = ""; + let resolvedTail = ""; + let resolvedAbsolute = false; + + for (let i = arguments.length - 1; i >= -1; i--) { + let path: string; + if (i >= 0) { + path = arguments[i]; + } else if (!resolvedDevice) { + path = cwd(); + } else { + // Windows has the concept of drive-specific current working + // directories. If we've resolved a drive letter but not yet an + // absolute path, get cwd for that drive, or the process cwd if + // the drive cwd is not available. We're sure the device is not + // a UNC path at this points, because UNC paths are always absolute. + path = env()[`=${resolvedDevice}`] || cwd(); + + // Verify that a cwd was found and that it actually points + // to our drive. If not, default to the drive's root. + if ( + path === undefined || + path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\` + ) { + path = `${resolvedDevice}\\`; + } + } + + assertPath(path); + + // Skip empty entries + if (path.length === 0) { + continue; + } + + let len = path.length; + let rootEnd = 0; + let device = ""; + let isAbsolute = false; + const code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + // If we started with a separator, we know we at least have an + // absolute path of some kind (UNC or otherwise) + isAbsolute = true; + + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + device = `\\\\${firstPart}\\${path.slice(last)}`; + rootEnd = j; + } else if (j !== last) { + // We matched a UNC root with leftovers + + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + // Treat separator following drive name as an absolute path + // indicator + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator + rootEnd = 1; + isAbsolute = true; + } + + if ( + device.length > 0 && + resolvedDevice.length > 0 && + device.toLowerCase() !== resolvedDevice.toLowerCase() + ) { + // This path points to another device so it is not applicable + continue; + } + + if (resolvedDevice.length === 0 && device.length > 0) { + resolvedDevice = device; + } + if (!resolvedAbsolute) { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + } + + if (resolvedDevice.length > 0 && resolvedAbsolute) { + break; + } + } + + // At this point the path should be resolved to a full absolute path, + // but handle relative paths to be safe (might happen when process.cwd() + // fails) + + // Normalize the tail path + resolvedTail = normalizeString( + resolvedTail, + !resolvedAbsolute, + "\\", + isPathSeparator + ); + + return ( + resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "." + ); + }, + + normalize: function normalize(path: string) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = 0; + let device: string; + let isAbsolute = false; + const code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + // If we started with a separator, we know we at least have an absolute + // path of some kind (UNC or otherwise) + isAbsolute = true; + + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + // Return the normalized version of the UNC root since there + // is nothing left to process + + return `\\\\${firstPart}\\${path.slice(last)}\\`; + } else if (j !== last) { + // We matched a UNC root with leftovers + + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + // Treat separator following drive name as an absolute path + // indicator + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid unnecessary + // work + return "\\"; + } + + let tail: string; + if (rootEnd < len) { + tail = normalizeString( + path.slice(rootEnd), + !isAbsolute, + "\\", + isPathSeparator + ); + } else { + tail = ""; + } + if (tail.length === 0 && !isAbsolute) tail = "."; + if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) + tail += "\\"; + if (device === undefined) { + if (isAbsolute) { + if (tail.length > 0) return `\\${tail}`; + else return "\\"; + } else if (tail.length > 0) { + return tail; + } else { + return ""; + } + } else if (isAbsolute) { + if (tail.length > 0) return `${device}\\${tail}`; + else return `${device}\\`; + } else if (tail.length > 0) { + return device + tail; + } else { + return device; + } + }, + + isAbsolute: function isAbsolute(path: string) { + assertPath(path); + const len = path.length; + if (len === 0) return false; + + const code = path.charCodeAt(0); + if (isPathSeparator(code)) { + return true; + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (len > 2 && path.charCodeAt(1) === CHAR_COLON) { + if (isPathSeparator(path.charCodeAt(2))) return true; + } + } + return false; + }, + + join: function join(...paths: string[]) { + if (arguments.length === 0) return "."; + + let joined: string; + let firstPart: string; + for (let i = 0; i < arguments.length; ++i) { + let arg = arguments[i]; + assertPath(arg); + if (arg.length > 0) { + if (joined === undefined) joined = firstPart = arg; + else joined += `\\${arg}`; + } + } + + if (joined === undefined) return "."; + + // Make sure that the joined path doesn't start with two slashes, because + // normalize() will mistake it for an UNC path then. + // + // This step is skipped when it is very clear that the user actually + // intended to point at an UNC path. This is assumed when the first + // non-empty string arguments starts with exactly two slashes followed by + // at least one more non-slash character. + // + // Note that for normalize() to treat a path as an UNC path it needs to + // have at least 2 components, so we don't filter for that here. + // This means that the user can use join to construct UNC paths from + // a server name and a share name; for example: + // path.join('//server', 'share') -> '\\\\server\\share\\') + let needsReplace = true; + let slashCount = 0; + if (isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1) { + if (isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; + else { + // We matched a UNC path in the first part + needsReplace = false; + } + } + } + } + } + if (needsReplace) { + // Find any more consecutive slashes we need to replace + for (; slashCount < joined.length; ++slashCount) { + if (!isPathSeparator(joined.charCodeAt(slashCount))) break; + } + + // Replace the slashes if needed + if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; + } + + return win32.normalize(joined); + }, + + // It will solve the relative path from `from` to `to`, for instance: + // from = 'C:\\orandea\\test\\aaa' + // to = 'C:\\orandea\\impl\\bbb' + // The output of the function should be: '..\\..\\impl\\bbb' + relative: function relative(from: string, to: string) { + assertPath(from); + assertPath(to); + + if (from === to) return ""; + + let fromOrig = win32.resolve(from); + let toOrig = win32.resolve(to); + + if (fromOrig === toOrig) return ""; + + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + + if (from === to) return ""; + + // Trim any leading backslashes + let fromStart = 0; + for (; fromStart < from.length; ++fromStart) { + if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + let fromEnd = from.length; + for (; fromEnd - 1 > fromStart; --fromEnd) { + if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + let fromLen = fromEnd - fromStart; + + // Trim any leading backslashes + let toStart = 0; + for (; toStart < to.length; ++toStart) { + if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + let toEnd = to.length; + for (; toEnd - 1 > toStart; --toEnd) { + if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + let toLen = toEnd - toStart; + + // Compare paths to find the longest common path from root + let length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for (; i <= length; ++i) { + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz' + return toOrig.slice(toStart + i + 1); + } else if (i === 2) { + // We get here if `from` is the device root. + // For example: from='C:\\'; to='C:\\foo' + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='C:\\foo\\bar'; to='C:\\foo' + lastCommonSep = i; + } else if (i === 2) { + // We get here if `to` is the device root. + // For example: from='C:\\foo\\bar'; to='C:\\' + lastCommonSep = 3; + } + } + break; + } + let fromCode = from.charCodeAt(fromStart + i); + let toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i; + } + + // We found a mismatch before the first common path separator was seen, so + // return the original `to`. + if (i !== length && lastCommonSep === -1) { + return toOrig; + } + + let out = ""; + if (lastCommonSep === -1) lastCommonSep = 0; + // Generate the relative path based on the path difference between `to` and + // `from` + for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { + if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "\\.."; + } + } + + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) + return out + toOrig.slice(toStart + lastCommonSep, toEnd); + else { + toStart += lastCommonSep; + if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart; + return toOrig.slice(toStart, toEnd); + } + }, + + toNamespacedPath: function toNamespacedPath(path: string) { + // Note: this will *probably* throw somewhere. + if (typeof path !== "string") return path; + + if (path.length === 0) { + return ""; + } + + const resolvedPath = win32.resolve(path); + + if (resolvedPath.length >= 3) { + if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { + // Possible UNC root + + if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { + const code = resolvedPath.charCodeAt(2); + if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { + // Matched non-long UNC root, convert the path to a long UNC path + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) { + // Possible device root + + if ( + resolvedPath.charCodeAt(1) === CHAR_COLON && + resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH + ) { + // Matched device root, convert the path to a long UNC path + return `\\\\?\\${resolvedPath}`; + } + } + } + + return path; + }, + + dirname: function dirname(path: string) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = -1; + let end = -1; + let matchedSlash = true; + let offset = 0; + const code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + rootEnd = offset = 1; + + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + return path; + } + if (j !== last) { + // We matched a UNC root with leftovers + + // Offset by 1 to include the separator after the UNC root to + // treat it as a "normal root" on top of a (UNC) root + rootEnd = offset = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = offset = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + return path; + } + + for (let i = len - 1; i >= offset; --i) { + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + + if (end === -1) { + if (rootEnd === -1) return "."; + else end = rootEnd; + } + return path.slice(0, end); + }, + + basename: function basename(path: string, ext = "") { + if (ext !== undefined && typeof ext !== "string") + throw new TypeError('"ext" argument must be a string'); + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i: number; + + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2) { + const drive = path.charCodeAt(0); + if (isWindowsDeviceRoot(drive)) { + if (path.charCodeAt(1) === CHAR_COLON) start = 2; + } + } + + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for (i = path.length - 1; i >= start; --i) { + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for (i = path.length - 1; i >= start; --i) { + if (isPathSeparator(path.charCodeAt(i))) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + + if (end === -1) return ""; + return path.slice(start, end); + } + }, + + extname: function extname(path: string) { + assertPath(path); + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + + if ( + path.length >= 2 && + path.charCodeAt(1) === CHAR_COLON && + isWindowsDeviceRoot(path.charCodeAt(0)) + ) { + start = startPart = 2; + } + + for (let i = path.length - 1; i >= start; --i) { + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + return ""; + } + return path.slice(startDot, end); + }, + + format: function format(pathObject: FormatInputPathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError( + `The "pathObject" argument must be of type Object. Received type ${typeof pathObject}` + ); + } + return _format("\\", pathObject); + }, + + parse: function parse(path: string) { + assertPath(path); + + let ret = { root: "", dir: "", base: "", ext: "", name: "" } as ParsedPath; + if (path.length === 0) return ret; + + let len = path.length; + let rootEnd = 0; + let code = path.charCodeAt(0); + + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + + rootEnd = 1; + if (isPathSeparator(path.charCodeAt(1))) { + // Matched double path separator at beginning + let j = 2; + let last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more path separators + for (; j < len; ++j) { + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + // Matched! + last = j; + // Match 1 or more non-path separators + for (; j < len; ++j) { + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + // We matched a UNC root only + + rootEnd = j; + } else if (j !== last) { + // We matched a UNC root with leftovers + + rootEnd = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + rootEnd = 3; + } + } else { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + + if (rootEnd > 0) ret.root = path.slice(0, rootEnd); + + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Get non-dir info + for (; i >= rootEnd; --i) { + code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + if (end !== -1) { + ret.base = ret.name = path.slice(startPart, end); + } + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + + // If the directory is the root, use the entire root as the `dir` including + // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the + // trailing slash (`C:\abc\def` -> `C:\abc`). + if (startPart > 0 && startPart !== rootEnd) + ret.dir = path.slice(0, startPart - 1); + else ret.dir = ret.root; + + return ret; + }, + + sep: "\\", + delimiter: ";", + win32: null, + posix: null +}; + +const posix = { + // path.resolve([from ...], to) + resolve: function resolve(...pathSegments: string[]) { + let resolvedPath = ""; + let resolvedAbsolute = false; + + for (let i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + let path: string; + if (i >= 0) path = arguments[i]; + else { + path = cwd(); + } + + assertPath(path); + + // Skip empty entries + if (path.length === 0) { + continue; + } + + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + + // Normalize the path + resolvedPath = normalizeString( + resolvedPath, + !resolvedAbsolute, + "/", + isPosixPathSeparator + ); + + if (resolvedAbsolute) { + if (resolvedPath.length > 0) return `/${resolvedPath}`; + else return "/"; + } else if (resolvedPath.length > 0) { + return resolvedPath; + } else { + return "."; + } + }, + + normalize: function normalize(path: string) { + assertPath(path); + + if (path.length === 0) return "."; + + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + const trailingSeparator = + path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH; + + // Normalize the path + path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator); + + if (path.length === 0 && !isAbsolute) path = "."; + if (path.length > 0 && trailingSeparator) path += "/"; + + if (isAbsolute) return `/${path}`; + return path; + }, + + isAbsolute: function isAbsolute(path: string) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH; + }, + + join: function join(...paths: string[]) { + if (arguments.length === 0) return "."; + let joined: string; + for (let i = 0; i < arguments.length; ++i) { + let arg = arguments[i]; + assertPath(arg); + if (arg.length > 0) { + if (joined === undefined) joined = arg; + else joined += `/${arg}`; + } + } + if (joined === undefined) return "."; + return posix.normalize(joined); + }, + + relative: function relative(from: string, to: string) { + assertPath(from); + assertPath(to); + + if (from === to) return ""; + + from = posix.resolve(from); + to = posix.resolve(to); + + if (from === to) return ""; + + // Trim any leading backslashes + let fromStart = 1; + for (; fromStart < from.length; ++fromStart) { + if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break; + } + let fromEnd = from.length; + let fromLen = fromEnd - fromStart; + + // Trim any leading backslashes + let toStart = 1; + for (; toStart < to.length; ++toStart) { + if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break; + } + let toEnd = to.length; + let toLen = toEnd - toStart; + + // Compare paths to find the longest common path from root + let length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for (; i <= length; ++i) { + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='/foo/bar'; to='/foo/bar/baz' + return to.slice(toStart + i + 1); + } else if (i === 0) { + // We get here if `from` is the root + // For example: from='/'; to='/foo' + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='/foo/bar/baz'; to='/foo/bar' + lastCommonSep = i; + } else if (i === 0) { + // We get here if `to` is the root. + // For example: from='/foo'; to='/' + lastCommonSep = 0; + } + } + break; + } + let fromCode = from.charCodeAt(fromStart + i); + let toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i; + } + + let out = ""; + // Generate the relative path based on the path difference between `to` + // and `from` + for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { + if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "/.."; + } + } + + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart; + return to.slice(toStart); + } + }, + + toNamespacedPath: function toNamespacedPath(path: string) { + // Non-op on posix systems + return path; + }, + + dirname: function dirname(path: string) { + assertPath(path); + if (path.length === 0) return "."; + const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let end = -1; + let matchedSlash = true; + for (let i = path.length - 1; i >= 1; --i) { + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + + if (end === -1) return hasRoot ? "/" : "."; + if (hasRoot && end === 1) return "//"; + return path.slice(0, end); + }, + + basename: function basename(path: string, ext = "") { + if (ext !== undefined && typeof ext !== "string") + throw new TypeError('"ext" argument must be a string'); + assertPath(path); + + let start = 0; + let end = -1; + let matchedSlash = true; + let i: number; + + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for (i = path.length - 1; i >= 0; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for (i = path.length - 1; i >= 0; --i) { + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + + if (end === -1) return ""; + return path.slice(start, end); + } + }, + + extname: function extname(path: string) { + assertPath(path); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + for (let i = path.length - 1; i >= 0; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + return ""; + } + return path.slice(startDot, end); + }, + + format: function format(pathObject: FormatInputPathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError( + `The "pathObject" argument must be of type Object. Received type ${typeof pathObject}` + ); + } + return _format("/", pathObject); + }, + + parse: function parse(path: string) { + assertPath(path); + + let ret = { root: "", dir: "", base: "", ext: "", name: "" } as ParsedPath; + if (path.length === 0) return ret; + let isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let start: number; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + + // Get non-dir info + for (; i >= start; --i) { + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + + if ( + startDot === -1 || + end === -1 || + // We saw a non-dot character immediately before the dot + preDotState === 0 || + // The (right-most) trimmed path component is exactly '..' + (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) + ) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) + ret.base = ret.name = path.slice(1, end); + else ret.base = ret.name = path.slice(startPart, end); + } + } else { + if (startPart === 0 && isAbsolute) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + + if (startPart > 0) ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) ret.dir = "/"; + + return ret; + }, + + sep: "/", + delimiter: ":", + win32: null, + posix: null +}; + +posix.win32 = win32.win32 = win32; +posix.posix = win32.posix = posix; + +const module = platform.os === "win" ? win32 : posix; +export = module; diff --git a/path/interface.ts b/path/interface.ts new file mode 100644 index 0000000000..84a3030ff0 --- /dev/null +++ b/path/interface.ts @@ -0,0 +1,47 @@ +/** + * A parsed path object generated by path.parse() or consumed by path.format(). + */ +export interface ParsedPath { + /** + * The root of the path such as '/' or 'c:\' + */ + root: string; + /** + * The full directory path such as '/home/user/dir' or 'c:\path\dir' + */ + dir: string; + /** + * The file name including extension (if any) such as 'index.html' + */ + base: string; + /** + * The file extension (if any) such as '.html' + */ + ext: string; + /** + * The file name without extension (if any) such as 'index' + */ + name: string; +} +export interface FormatInputPathObject { + /** + * The root of the path such as '/' or 'c:\' + */ + root?: string; + /** + * The full directory path such as '/home/user/dir' or 'c:\path\dir' + */ + dir?: string; + /** + * The file name including extension (if any) such as 'index.html' + */ + base?: string; + /** + * The file extension (if any) such as '.html' + */ + ext?: string; + /** + * The file name without extension (if any) such as 'index' + */ + name?: string; +} diff --git a/path/isabsolute_test.ts b/path/isabsolute_test.ts new file mode 100644 index 0000000000..c338dbc035 --- /dev/null +++ b/path/isabsolute_test.ts @@ -0,0 +1,33 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +test(function isAbsolute() { + assertEqual(path.posix.isAbsolute("/home/foo"), true); + assertEqual(path.posix.isAbsolute("/home/foo/.."), true); + assertEqual(path.posix.isAbsolute("bar/"), false); + assertEqual(path.posix.isAbsolute("./baz"), false); +}); + +test(function isAbsoluteWin32() { + assertEqual(path.win32.isAbsolute("/"), true); + assertEqual(path.win32.isAbsolute("//"), true); + assertEqual(path.win32.isAbsolute("//server"), true); + assertEqual(path.win32.isAbsolute("//server/file"), true); + assertEqual(path.win32.isAbsolute("\\\\server\\file"), true); + assertEqual(path.win32.isAbsolute("\\\\server"), true); + assertEqual(path.win32.isAbsolute("\\\\"), true); + assertEqual(path.win32.isAbsolute("c"), false); + assertEqual(path.win32.isAbsolute("c:"), false); + assertEqual(path.win32.isAbsolute("c:\\"), true); + assertEqual(path.win32.isAbsolute("c:/"), true); + assertEqual(path.win32.isAbsolute("c://"), true); + assertEqual(path.win32.isAbsolute("C:/Users/"), true); + assertEqual(path.win32.isAbsolute("C:\\Users\\"), true); + assertEqual(path.win32.isAbsolute("C:cwd/another"), false); + assertEqual(path.win32.isAbsolute("C:cwd\\another"), false); + assertEqual(path.win32.isAbsolute("directory/directory"), false); + assertEqual(path.win32.isAbsolute("directory\\directory"), false); +}); diff --git a/path/join_test.ts b/path/join_test.ts new file mode 100644 index 0000000000..70b78c7be7 --- /dev/null +++ b/path/join_test.ts @@ -0,0 +1,124 @@ +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +const backslashRE = /\\/g; + +const joinTests = + // arguments result + [ + [[".", "x/b", "..", "/b/c.js"], "x/b/c.js"], + [[], "."], + [["/.", "x/b", "..", "/b/c.js"], "/x/b/c.js"], + [["/foo", "../../../bar"], "/bar"], + [["foo", "../../../bar"], "../../bar"], + [["foo/", "../../../bar"], "../../bar"], + [["foo/x", "../../../bar"], "../bar"], + [["foo/x", "./bar"], "foo/x/bar"], + [["foo/x/", "./bar"], "foo/x/bar"], + [["foo/x/", ".", "bar"], "foo/x/bar"], + [["./"], "./"], + [[".", "./"], "./"], + [[".", ".", "."], "."], + [[".", "./", "."], "."], + [[".", "/./", "."], "."], + [[".", "/////./", "."], "."], + [["."], "."], + [["", "."], "."], + [["", "foo"], "foo"], + [["foo", "/bar"], "foo/bar"], + [["", "/foo"], "/foo"], + [["", "", "/foo"], "/foo"], + [["", "", "foo"], "foo"], + [["foo", ""], "foo"], + [["foo/", ""], "foo/"], + [["foo", "", "/bar"], "foo/bar"], + [["./", "..", "/foo"], "../foo"], + [["./", "..", "..", "/foo"], "../../foo"], + [[".", "..", "..", "/foo"], "../../foo"], + [["", "..", "..", "/foo"], "../../foo"], + [["/"], "/"], + [["/", "."], "/"], + [["/", ".."], "/"], + [["/", "..", ".."], "/"], + [[""], "."], + [["", ""], "."], + [[" /foo"], " /foo"], + [[" ", "foo"], " /foo"], + [[" ", "."], " "], + [[" ", "/"], " /"], + [[" ", ""], " "], + [["/", "foo"], "/foo"], + [["/", "/foo"], "/foo"], + [["/", "//foo"], "/foo"], + [["/", "", "/foo"], "/foo"], + [["", "/", "foo"], "/foo"], + [["", "/", "/foo"], "/foo"] + ]; + +// Windows-specific join tests +const windowsJoinTests = [ + // arguments result + // UNC path expected + [["//foo/bar"], "\\\\foo\\bar\\"], + [["\\/foo/bar"], "\\\\foo\\bar\\"], + [["\\\\foo/bar"], "\\\\foo\\bar\\"], + // UNC path expected - server and share separate + [["//foo", "bar"], "\\\\foo\\bar\\"], + [["//foo/", "bar"], "\\\\foo\\bar\\"], + [["//foo", "/bar"], "\\\\foo\\bar\\"], + // UNC path expected - questionable + [["//foo", "", "bar"], "\\\\foo\\bar\\"], + [["//foo/", "", "bar"], "\\\\foo\\bar\\"], + [["//foo/", "", "/bar"], "\\\\foo\\bar\\"], + // UNC path expected - even more questionable + [["", "//foo", "bar"], "\\\\foo\\bar\\"], + [["", "//foo/", "bar"], "\\\\foo\\bar\\"], + [["", "//foo/", "/bar"], "\\\\foo\\bar\\"], + // No UNC path expected (no double slash in first component) + [["\\", "foo/bar"], "\\foo\\bar"], + [["\\", "/foo/bar"], "\\foo\\bar"], + [["", "/", "/foo/bar"], "\\foo\\bar"], + // No UNC path expected (no non-slashes in first component - + // questionable) + [["//", "foo/bar"], "\\foo\\bar"], + [["//", "/foo/bar"], "\\foo\\bar"], + [["\\\\", "/", "/foo/bar"], "\\foo\\bar"], + [["//"], "\\"], + // No UNC path expected (share name missing - questionable). + [["//foo"], "\\foo"], + [["//foo/"], "\\foo\\"], + [["//foo", "/"], "\\foo\\"], + [["//foo", "", "/"], "\\foo\\"], + // No UNC path expected (too many leading slashes - questionable) + [["///foo/bar"], "\\foo\\bar"], + [["////foo", "bar"], "\\foo\\bar"], + [["\\\\\\/foo/bar"], "\\foo\\bar"], + // Drive-relative vs drive-absolute paths. This merely describes the + // status quo, rather than being obviously right + [["c:"], "c:."], + [["c:."], "c:."], + [["c:", ""], "c:."], + [["", "c:"], "c:."], + [["c:.", "/"], "c:.\\"], + [["c:.", "file"], "c:file"], + [["c:", "/"], "c:\\"], + [["c:", "file"], "c:\\file"] +]; + +test(function join() { + joinTests.forEach(function(p) { + const actual = path.posix.join.apply(null, p[0]); + assertEqual(actual, p[1]); + }); +}); + +test(function joinWin32() { + joinTests.forEach(function(p) { + const actual = path.win32.join.apply(null, p[0]).replace(backslashRE, "/"); + assertEqual(actual, p[1]); + }); + windowsJoinTests.forEach(function(p) { + const actual = path.win32.join.apply(null, p[0]); + assertEqual(actual, p[1]); + }); +}); diff --git a/path/parse_format_test.ts b/path/parse_format_test.ts new file mode 100644 index 0000000000..b15026975e --- /dev/null +++ b/path/parse_format_test.ts @@ -0,0 +1,176 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +const winPaths = [ + // [path, root] + ["C:\\path\\dir\\index.html", "C:\\"], + ["C:\\another_path\\DIR\\1\\2\\33\\\\index", "C:\\"], + ["another_path\\DIR with spaces\\1\\2\\33\\index", ""], + ["\\", "\\"], + ["\\foo\\C:", "\\"], + ["file", ""], + ["file:stream", ""], + [".\\file", ""], + ["C:", "C:"], + ["C:.", "C:"], + ["C:..", "C:"], + ["C:abc", "C:"], + ["C:\\", "C:\\"], + ["C:\\abc", "C:\\"], + ["", ""], + + // unc + ["\\\\server\\share\\file_path", "\\\\server\\share\\"], + [ + "\\\\server two\\shared folder\\file path.zip", + "\\\\server two\\shared folder\\" + ], + ["\\\\teela\\admin$\\system32", "\\\\teela\\admin$\\"], + ["\\\\?\\UNC\\server\\share", "\\\\?\\UNC\\"] +]; + +const winSpecialCaseParseTests = [["/foo/bar", { root: "/" }]]; + +const winSpecialCaseFormatTests = [ + [{ dir: "some\\dir" }, "some\\dir\\"], + [{ base: "index.html" }, "index.html"], + [{ root: "C:\\" }, "C:\\"], + [{ name: "index", ext: ".html" }, "index.html"], + [{ dir: "some\\dir", name: "index", ext: ".html" }, "some\\dir\\index.html"], + [{ root: "C:\\", name: "index", ext: ".html" }, "C:\\index.html"], + [{}, ""] +]; + +const unixPaths = [ + // [path, root] + ["/home/user/dir/file.txt", "/"], + ["/home/user/a dir/another File.zip", "/"], + ["/home/user/a dir//another&File.", "/"], + ["/home/user/a$$$dir//another File.zip", "/"], + ["user/dir/another File.zip", ""], + ["file", ""], + [".\\file", ""], + ["./file", ""], + ["C:\\foo", ""], + ["/", "/"], + ["", ""], + [".", ""], + ["..", ""], + ["/foo", "/"], + ["/foo.", "/"], + ["/foo.bar", "/"], + ["/.", "/"], + ["/.foo", "/"], + ["/.foo.bar", "/"], + ["/foo/bar.baz", "/"] +]; + +const unixSpecialCaseFormatTests = [ + [{ dir: "some/dir" }, "some/dir/"], + [{ base: "index.html" }, "index.html"], + [{ root: "/" }, "/"], + [{ name: "index", ext: ".html" }, "index.html"], + [{ dir: "some/dir", name: "index", ext: ".html" }, "some/dir/index.html"], + [{ root: "/", name: "index", ext: ".html" }, "/index.html"], + [{}, ""] +]; + +test(function parseWin32() { + checkParseFormat(path.win32, winPaths); + checkSpecialCaseParseFormat(path.win32, winSpecialCaseParseTests); +}); + +test(function parse() { + checkParseFormat(path.posix, unixPaths); +}); + +test(function formatWin32() { + checkFormat(path.win32, winSpecialCaseFormatTests); +}); + +test(function format() { + checkFormat(path.posix, unixSpecialCaseFormatTests); +}); + +// Test removal of trailing path separators +const windowsTrailingTests = [ + [".\\", { root: "", dir: "", base: ".", ext: "", name: "." }], + ["\\\\", { root: "\\", dir: "\\", base: "", ext: "", name: "" }], + ["\\\\", { root: "\\", dir: "\\", base: "", ext: "", name: "" }], + [ + "c:\\foo\\\\\\", + { root: "c:\\", dir: "c:\\", base: "foo", ext: "", name: "foo" } + ], + [ + "D:\\foo\\\\\\bar.baz", + { + root: "D:\\", + dir: "D:\\foo\\\\", + base: "bar.baz", + ext: ".baz", + name: "bar" + } + ] +]; +const posixTrailingTests = [ + ["./", { root: "", dir: "", base: ".", ext: "", name: "." }], + ["//", { root: "/", dir: "/", base: "", ext: "", name: "" }], + ["///", { root: "/", dir: "/", base: "", ext: "", name: "" }], + ["/foo///", { root: "/", dir: "/", base: "foo", ext: "", name: "foo" }], + [ + "/foo///bar.baz", + { root: "/", dir: "/foo//", base: "bar.baz", ext: ".baz", name: "bar" } + ] +]; + +function checkParseFormat(path, paths) { + paths.forEach(function(p) { + const element = p[0]; + const output = path.parse(element); + assertEqual(typeof output.root, "string"); + assertEqual(typeof output.dir, "string"); + assertEqual(typeof output.base, "string"); + assertEqual(typeof output.ext, "string"); + assertEqual(typeof output.name, "string"); + assertEqual(path.format(output), element); + assertEqual(output.rooroot, undefined); + assertEqual(output.dir, output.dir ? path.dirname(element) : ""); + assertEqual(output.base, path.basename(element)); + }); +} + +function checkSpecialCaseParseFormat(path, testCases) { + testCases.forEach(function(testCase) { + const element = testCase[0]; + const expect = testCase[1]; + const output = path.parse(element); + Object.keys(expect).forEach(function(key) { + assertEqual(output[key], expect[key]); + }); + }); +} + +function checkFormat(path, testCases) { + testCases.forEach(function(testCase) { + assertEqual(path.format(testCase[0]), testCase[1]); + }); +} + +test(function parseTrailingWin32() { + windowsTrailingTests.forEach(function(p) { + const actual = path.win32.parse(p[0]); + const expected = p[1]; + assertEqual(actual, expected); + }); +}); + +test(function parseTrailing() { + posixTrailingTests.forEach(function(p) { + const actual = path.posix.parse(p[0]); + const expected = p[1]; + assertEqual(actual, expected); + }); +}); diff --git a/path/relative_test.ts b/path/relative_test.ts new file mode 100644 index 0000000000..7e77376c6b --- /dev/null +++ b/path/relative_test.ts @@ -0,0 +1,72 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; + +const relativeTests = { + win32: + // arguments result + [ + ["c:/blah\\blah", "d:/games", "d:\\games"], + ["c:/aaaa/bbbb", "c:/aaaa", ".."], + ["c:/aaaa/bbbb", "c:/cccc", "..\\..\\cccc"], + ["c:/aaaa/bbbb", "c:/aaaa/bbbb", ""], + ["c:/aaaa/bbbb", "c:/aaaa/cccc", "..\\cccc"], + ["c:/aaaa/", "c:/aaaa/cccc", "cccc"], + ["c:/", "c:\\aaaa\\bbbb", "aaaa\\bbbb"], + ["c:/aaaa/bbbb", "d:\\", "d:\\"], + ["c:/AaAa/bbbb", "c:/aaaa/bbbb", ""], + ["c:/aaaaa/", "c:/aaaa/cccc", "..\\aaaa\\cccc"], + ["C:\\foo\\bar\\baz\\quux", "C:\\", "..\\..\\..\\.."], + [ + "C:\\foo\\test", + "C:\\foo\\test\\bar\\package.json", + "bar\\package.json" + ], + ["C:\\foo\\bar\\baz-quux", "C:\\foo\\bar\\baz", "..\\baz"], + ["C:\\foo\\bar\\baz", "C:\\foo\\bar\\baz-quux", "..\\baz-quux"], + ["\\\\foo\\bar", "\\\\foo\\bar\\baz", "baz"], + ["\\\\foo\\bar\\baz", "\\\\foo\\bar", ".."], + ["\\\\foo\\bar\\baz-quux", "\\\\foo\\bar\\baz", "..\\baz"], + ["\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz-quux", "..\\baz-quux"], + ["C:\\baz-quux", "C:\\baz", "..\\baz"], + ["C:\\baz", "C:\\baz-quux", "..\\baz-quux"], + ["\\\\foo\\baz-quux", "\\\\foo\\baz", "..\\baz"], + ["\\\\foo\\baz", "\\\\foo\\baz-quux", "..\\baz-quux"], + ["C:\\baz", "\\\\foo\\bar\\baz", "\\\\foo\\bar\\baz"], + ["\\\\foo\\bar\\baz", "C:\\baz", "C:\\baz"] + ], + posix: + // arguments result + [ + ["/var/lib", "/var", ".."], + ["/var/lib", "/bin", "../../bin"], + ["/var/lib", "/var/lib", ""], + ["/var/lib", "/var/apache", "../apache"], + ["/var/", "/var/lib", "lib"], + ["/", "/var/lib", "var/lib"], + ["/foo/test", "/foo/test/bar/package.json", "bar/package.json"], + ["/Users/a/web/b/test/mails", "/Users/a/web/b", "../.."], + ["/foo/bar/baz-quux", "/foo/bar/baz", "../baz"], + ["/foo/bar/baz", "/foo/bar/baz-quux", "../baz-quux"], + ["/baz-quux", "/baz", "../baz"], + ["/baz", "/baz-quux", "../baz-quux"] + ] +}; + +test(function relative() { + relativeTests.posix.forEach(function(p) { + const expected = p[2]; + const actual = path.posix.relative(p[0], p[1]); + assertEqual(actual, expected); + }); +}); + +test(function relativeWin32() { + relativeTests.win32.forEach(function(p) { + const expected = p[2]; + const actual = path.win32.relative(p[0], p[1]); + assertEqual(actual, expected); + }); +}); diff --git a/path/resolve_test.ts b/path/resolve_test.ts new file mode 100644 index 0000000000..1b3d580ed9 --- /dev/null +++ b/path/resolve_test.ts @@ -0,0 +1,49 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; +import { cwd } from "deno"; + +const windowsTests = + // arguments result + [ + [["c:/blah\\blah", "d:/games", "c:../a"], "c:\\blah\\a"], + [["c:/ignore", "d:\\a/b\\c/d", "\\e.exe"], "d:\\e.exe"], + [["c:/ignore", "c:/some/file"], "c:\\some\\file"], + [["d:/ignore", "d:some/dir//"], "d:\\ignore\\some\\dir"], + [["//server/share", "..", "relative\\"], "\\\\server\\share\\relative"], + [["c:/", "//"], "c:\\"], + [["c:/", "//dir"], "c:\\dir"], + [["c:/", "//server/share"], "\\\\server\\share\\"], + [["c:/", "//server//share"], "\\\\server\\share\\"], + [["c:/", "///some//dir"], "c:\\some\\dir"], + [ + ["C:\\foo\\tmp.3\\", "..\\tmp.3\\cycles\\root.js"], + "C:\\foo\\tmp.3\\cycles\\root.js" + ] + ]; +const posixTests = + // arguments result + [ + [["/var/lib", "../", "file/"], "/var/file"], + [["/var/lib", "/../", "file/"], "/file"], + [["a/b/c/", "../../.."], cwd()], + [["."], cwd()], + [["/some/dir", ".", "/absolute/"], "/absolute"], + [["/foo/tmp.3/", "../tmp.3/cycles/root.js"], "/foo/tmp.3/cycles/root.js"] + ]; + +test(function resolve() { + posixTests.forEach(function(p) { + const actual = path.posix.resolve.apply(null, p[0]); + assertEqual(actual, p[1]); + }); +}); + +test(function resolveWin32() { + windowsTests.forEach(function(p) { + const actual = path.win32.resolve.apply(null, p[0]); + assertEqual(actual, p[1]); + }); +}); diff --git a/path/zero_length_strings_test.ts b/path/zero_length_strings_test.ts new file mode 100644 index 0000000000..dec9696d3b --- /dev/null +++ b/path/zero_length_strings_test.ts @@ -0,0 +1,46 @@ +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ + +import { test, assertEqual } from "https://deno.land/x/testing/testing.ts"; +import * as path from "./index"; +import { cwd } from "deno"; + +const pwd = cwd(); + +test(function joinZeroLength() { + // join will internally ignore all the zero-length strings and it will return + // '.' if the joined string is a zero-length string. + assertEqual(path.posix.join(""), "."); + assertEqual(path.posix.join("", ""), "."); + if (path.win32) assertEqual(path.win32.join(""), "."); + if (path.win32) assertEqual(path.win32.join("", ""), "."); + assertEqual(path.join(pwd), pwd); + assertEqual(path.join(pwd, ""), pwd); +}); + +test(function normalizeZeroLength() { + // normalize will return '.' if the input is a zero-length string + assertEqual(path.posix.normalize(""), "."); + if (path.win32) assertEqual(path.win32.normalize(""), "."); + assertEqual(path.normalize(pwd), pwd); +}); + +test(function isAbsoluteZeroLength() { + // Since '' is not a valid path in any of the common environments, return false + assertEqual(path.posix.isAbsolute(""), false); + if (path.win32) assertEqual(path.win32.isAbsolute(""), false); +}); + +test(function resolveZeroLength() { + // resolve, internally ignores all the zero-length strings and returns the + // current working directory + assertEqual(path.resolve(""), pwd); + assertEqual(path.resolve("", ""), pwd); +}); + +test(function relativeZeroLength() { + // relative, internally calls resolve. So, '' is actually the current directory + assertEqual(path.relative("", pwd), ""); + assertEqual(path.relative(pwd, ""), ""); + assertEqual(path.relative(pwd, pwd), ""); +}); diff --git a/test.ts b/test.ts index 95003e0adc..54413ecd95 100755 --- a/test.ts +++ b/test.ts @@ -1,5 +1,5 @@ #!/usr/bin/env deno --allow-run --allow-net -import { run } from "deno"; +import { run, exit } from "deno"; import "net/bufio_test.ts"; import "net/http_test.ts"; @@ -10,6 +10,17 @@ import { runTests, completePromise } from "net/file_server_test.ts"; const fileServer = run({ args: ["deno", "--allow-net", "net/file_server.ts", "."] }); +// path test +import "path/basename_test.ts"; +import "path/dirname_test.ts"; +import "path/extname_test.ts"; +import "path/isabsolute_test.ts"; +import "path/join_test.ts"; +import "path/parse_format_test.ts"; +import "path/relative_test.ts"; +import "path/resolve_test.ts"; +import "path/zero_length_strings_test.ts"; + // I am also too lazy to do this properly LOL runTests(new Promise(res => setTimeout(res, 5000))); (async () => {