Permalink
Cannot retrieve contributors at this time
198 lines (198 sloc)
7.29 KB
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
codeql-action/node_modules/@actions/glob/lib/internal-path-helper.js
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
"use strict"; | |
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | |
if (k2 === undefined) k2 = k; | |
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | |
}) : (function(o, m, k, k2) { | |
if (k2 === undefined) k2 = k; | |
o[k2] = m[k]; | |
})); | |
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | |
Object.defineProperty(o, "default", { enumerable: true, value: v }); | |
}) : function(o, v) { | |
o["default"] = v; | |
}); | |
var __importStar = (this && this.__importStar) || function (mod) { | |
if (mod && mod.__esModule) return mod; | |
var result = {}; | |
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | |
__setModuleDefault(result, mod); | |
return result; | |
}; | |
var __importDefault = (this && this.__importDefault) || function (mod) { | |
return (mod && mod.__esModule) ? mod : { "default": mod }; | |
}; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.safeTrimTrailingSeparator = exports.normalizeSeparators = exports.hasRoot = exports.hasAbsoluteRoot = exports.ensureAbsoluteRoot = exports.dirname = void 0; | |
const path = __importStar(require("path")); | |
const assert_1 = __importDefault(require("assert")); | |
const IS_WINDOWS = process.platform === 'win32'; | |
/** | |
* Similar to path.dirname except normalizes the path separators and slightly better handling for Windows UNC paths. | |
* | |
* For example, on Linux/macOS: | |
* - `/ => /` | |
* - `/hello => /` | |
* | |
* For example, on Windows: | |
* - `C:\ => C:\` | |
* - `C:\hello => C:\` | |
* - `C: => C:` | |
* - `C:hello => C:` | |
* - `\ => \` | |
* - `\hello => \` | |
* - `\\hello => \\hello` | |
* - `\\hello\world => \\hello\world` | |
*/ | |
function dirname(p) { | |
// Normalize slashes and trim unnecessary trailing slash | |
p = safeTrimTrailingSeparator(p); | |
// Windows UNC root, e.g. \\hello or \\hello\world | |
if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) { | |
return p; | |
} | |
// Get dirname | |
let result = path.dirname(p); | |
// Trim trailing slash for Windows UNC root, e.g. \\hello\world\ | |
if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) { | |
result = safeTrimTrailingSeparator(result); | |
} | |
return result; | |
} | |
exports.dirname = dirname; | |
/** | |
* Roots the path if not already rooted. On Windows, relative roots like `\` | |
* or `C:` are expanded based on the current working directory. | |
*/ | |
function ensureAbsoluteRoot(root, itemPath) { | |
assert_1.default(root, `ensureAbsoluteRoot parameter 'root' must not be empty`); | |
assert_1.default(itemPath, `ensureAbsoluteRoot parameter 'itemPath' must not be empty`); | |
// Already rooted | |
if (hasAbsoluteRoot(itemPath)) { | |
return itemPath; | |
} | |
// Windows | |
if (IS_WINDOWS) { | |
// Check for itemPath like C: or C:foo | |
if (itemPath.match(/^[A-Z]:[^\\/]|^[A-Z]:$/i)) { | |
let cwd = process.cwd(); | |
assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); | |
// Drive letter matches cwd? Expand to cwd | |
if (itemPath[0].toUpperCase() === cwd[0].toUpperCase()) { | |
// Drive only, e.g. C: | |
if (itemPath.length === 2) { | |
// Preserve specified drive letter case (upper or lower) | |
return `${itemPath[0]}:\\${cwd.substr(3)}`; | |
} | |
// Drive + path, e.g. C:foo | |
else { | |
if (!cwd.endsWith('\\')) { | |
cwd += '\\'; | |
} | |
// Preserve specified drive letter case (upper or lower) | |
return `${itemPath[0]}:\\${cwd.substr(3)}${itemPath.substr(2)}`; | |
} | |
} | |
// Different drive | |
else { | |
return `${itemPath[0]}:\\${itemPath.substr(2)}`; | |
} | |
} | |
// Check for itemPath like \ or \foo | |
else if (normalizeSeparators(itemPath).match(/^\\$|^\\[^\\]/)) { | |
const cwd = process.cwd(); | |
assert_1.default(cwd.match(/^[A-Z]:\\/i), `Expected current directory to start with an absolute drive root. Actual '${cwd}'`); | |
return `${cwd[0]}:\\${itemPath.substr(1)}`; | |
} | |
} | |
assert_1.default(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`); | |
// Otherwise ensure root ends with a separator | |
if (root.endsWith('/') || (IS_WINDOWS && root.endsWith('\\'))) { | |
// Intentionally empty | |
} | |
else { | |
// Append separator | |
root += path.sep; | |
} | |
return root + itemPath; | |
} | |
exports.ensureAbsoluteRoot = ensureAbsoluteRoot; | |
/** | |
* On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: | |
* `\\hello\share` and `C:\hello` (and using alternate separator). | |
*/ | |
function hasAbsoluteRoot(itemPath) { | |
assert_1.default(itemPath, `hasAbsoluteRoot parameter 'itemPath' must not be empty`); | |
// Normalize separators | |
itemPath = normalizeSeparators(itemPath); | |
// Windows | |
if (IS_WINDOWS) { | |
// E.g. \\hello\share or C:\hello | |
return itemPath.startsWith('\\\\') || /^[A-Z]:\\/i.test(itemPath); | |
} | |
// E.g. /hello | |
return itemPath.startsWith('/'); | |
} | |
exports.hasAbsoluteRoot = hasAbsoluteRoot; | |
/** | |
* On Linux/macOS, true if path starts with `/`. On Windows, true for paths like: | |
* `\`, `\hello`, `\\hello\share`, `C:`, and `C:\hello` (and using alternate separator). | |
*/ | |
function hasRoot(itemPath) { | |
assert_1.default(itemPath, `isRooted parameter 'itemPath' must not be empty`); | |
// Normalize separators | |
itemPath = normalizeSeparators(itemPath); | |
// Windows | |
if (IS_WINDOWS) { | |
// E.g. \ or \hello or \\hello | |
// E.g. C: or C:\hello | |
return itemPath.startsWith('\\') || /^[A-Z]:/i.test(itemPath); | |
} | |
// E.g. /hello | |
return itemPath.startsWith('/'); | |
} | |
exports.hasRoot = hasRoot; | |
/** | |
* Removes redundant slashes and converts `/` to `\` on Windows | |
*/ | |
function normalizeSeparators(p) { | |
p = p || ''; | |
// Windows | |
if (IS_WINDOWS) { | |
// Convert slashes on Windows | |
p = p.replace(/\//g, '\\'); | |
// Remove redundant slashes | |
const isUnc = /^\\\\+[^\\]/.test(p); // e.g. \\hello | |
return (isUnc ? '\\' : '') + p.replace(/\\\\+/g, '\\'); // preserve leading \\ for UNC | |
} | |
// Remove redundant slashes | |
return p.replace(/\/\/+/g, '/'); | |
} | |
exports.normalizeSeparators = normalizeSeparators; | |
/** | |
* Normalizes the path separators and trims the trailing separator (when safe). | |
* For example, `/foo/ => /foo` but `/ => /` | |
*/ | |
function safeTrimTrailingSeparator(p) { | |
// Short-circuit if empty | |
if (!p) { | |
return ''; | |
} | |
// Normalize separators | |
p = normalizeSeparators(p); | |
// No trailing slash | |
if (!p.endsWith(path.sep)) { | |
return p; | |
} | |
// Check '/' on Linux/macOS and '\' on Windows | |
if (p === path.sep) { | |
return p; | |
} | |
// On Windows check if drive root. E.g. C:\ | |
if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) { | |
return p; | |
} | |
// Otherwise trim trailing slash | |
return p.substr(0, p.length - 1); | |
} | |
exports.safeTrimTrailingSeparator = safeTrimTrailingSeparator; | |
//# sourceMappingURL=internal-path-helper.js.map |