mirror of
https://github.com/diligencia/semantic-branch-version.git
synced 2024-11-24 05:53:51 +08:00
290 lines
11 KiB
JavaScript
290 lines
11 KiB
JavaScript
|
"use strict";
|
||
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
||
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
|
|
});
|
||
|
|
};
|
||
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
||
|
|
const childProcess = require("child_process");
|
||
|
|
const path = require("path");
|
||
|
|
const util_1 = require("util");
|
||
|
|
const ioUtil = require("./io-util");
|
||
|
|
const exec = util_1.promisify(childProcess.exec);
|
||
|
|
/**
|
||
|
|
* Copies a file or folder.
|
||
|
|
* Based off of shelljs - https://github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
|
||
|
|
*
|
||
|
|
* @param source source path
|
||
|
|
* @param dest destination path
|
||
|
|
* @param options optional. See CopyOptions.
|
||
|
|
*/
|
||
|
|
function cp(source, dest, options = {}) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
const { force, recursive } = readCopyOptions(options);
|
||
|
|
const destStat = (yield ioUtil.exists(dest)) ? yield ioUtil.stat(dest) : null;
|
||
|
|
// Dest is an existing file, but not forcing
|
||
|
|
if (destStat && destStat.isFile() && !force) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// If dest is an existing directory, should copy inside.
|
||
|
|
const newDest = destStat && destStat.isDirectory()
|
||
|
|
? path.join(dest, path.basename(source))
|
||
|
|
: dest;
|
||
|
|
if (!(yield ioUtil.exists(source))) {
|
||
|
|
throw new Error(`no such file or directory: ${source}`);
|
||
|
|
}
|
||
|
|
const sourceStat = yield ioUtil.stat(source);
|
||
|
|
if (sourceStat.isDirectory()) {
|
||
|
|
if (!recursive) {
|
||
|
|
throw new Error(`Failed to copy. ${source} is a directory, but tried to copy without recursive flag.`);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
yield cpDirRecursive(source, newDest, 0, force);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
if (path.relative(source, newDest) === '') {
|
||
|
|
// a file cannot be copied to itself
|
||
|
|
throw new Error(`'${newDest}' and '${source}' are the same file`);
|
||
|
|
}
|
||
|
|
yield copyFile(source, newDest, force);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
exports.cp = cp;
|
||
|
|
/**
|
||
|
|
* Moves a path.
|
||
|
|
*
|
||
|
|
* @param source source path
|
||
|
|
* @param dest destination path
|
||
|
|
* @param options optional. See MoveOptions.
|
||
|
|
*/
|
||
|
|
function mv(source, dest, options = {}) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
if (yield ioUtil.exists(dest)) {
|
||
|
|
let destExists = true;
|
||
|
|
if (yield ioUtil.isDirectory(dest)) {
|
||
|
|
// If dest is directory copy src into dest
|
||
|
|
dest = path.join(dest, path.basename(source));
|
||
|
|
destExists = yield ioUtil.exists(dest);
|
||
|
|
}
|
||
|
|
if (destExists) {
|
||
|
|
if (options.force == null || options.force) {
|
||
|
|
yield rmRF(dest);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
throw new Error('Destination already exists');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
yield mkdirP(path.dirname(dest));
|
||
|
|
yield ioUtil.rename(source, dest);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
exports.mv = mv;
|
||
|
|
/**
|
||
|
|
* Remove a path recursively with force
|
||
|
|
*
|
||
|
|
* @param inputPath path to remove
|
||
|
|
*/
|
||
|
|
function rmRF(inputPath) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
if (ioUtil.IS_WINDOWS) {
|
||
|
|
// Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
|
||
|
|
// program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
|
||
|
|
try {
|
||
|
|
if (yield ioUtil.isDirectory(inputPath, true)) {
|
||
|
|
yield exec(`rd /s /q "${inputPath}"`);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
yield exec(`del /f /a "${inputPath}"`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
// if you try to delete a file that doesn't exist, desired result is achieved
|
||
|
|
// other errors are valid
|
||
|
|
if (err.code !== 'ENOENT')
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
// Shelling out fails to remove a symlink folder with missing source, this unlink catches that
|
||
|
|
try {
|
||
|
|
yield ioUtil.unlink(inputPath);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
// if you try to delete a file that doesn't exist, desired result is achieved
|
||
|
|
// other errors are valid
|
||
|
|
if (err.code !== 'ENOENT')
|
||
|
|
throw err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
let isDir = false;
|
||
|
|
try {
|
||
|
|
isDir = yield ioUtil.isDirectory(inputPath);
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
// if you try to delete a file that doesn't exist, desired result is achieved
|
||
|
|
// other errors are valid
|
||
|
|
if (err.code !== 'ENOENT')
|
||
|
|
throw err;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (isDir) {
|
||
|
|
yield exec(`rm -rf "${inputPath}"`);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
yield ioUtil.unlink(inputPath);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
exports.rmRF = rmRF;
|
||
|
|
/**
|
||
|
|
* Make a directory. Creates the full path with folders in between
|
||
|
|
* Will throw if it fails
|
||
|
|
*
|
||
|
|
* @param fsPath path to create
|
||
|
|
* @returns Promise<void>
|
||
|
|
*/
|
||
|
|
function mkdirP(fsPath) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
yield ioUtil.mkdirP(fsPath);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
exports.mkdirP = mkdirP;
|
||
|
|
/**
|
||
|
|
* Returns path of a tool had the tool actually been invoked. Resolves via paths.
|
||
|
|
* If you check and the tool does not exist, it will throw.
|
||
|
|
*
|
||
|
|
* @param tool name of the tool
|
||
|
|
* @param check whether to check if tool exists
|
||
|
|
* @returns Promise<string> path to tool
|
||
|
|
*/
|
||
|
|
function which(tool, check) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
if (!tool) {
|
||
|
|
throw new Error("parameter 'tool' is required");
|
||
|
|
}
|
||
|
|
// recursive when check=true
|
||
|
|
if (check) {
|
||
|
|
const result = yield which(tool, false);
|
||
|
|
if (!result) {
|
||
|
|
if (ioUtil.IS_WINDOWS) {
|
||
|
|
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file.`);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
throw new Error(`Unable to locate executable file: ${tool}. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
try {
|
||
|
|
// build the list of extensions to try
|
||
|
|
const extensions = [];
|
||
|
|
if (ioUtil.IS_WINDOWS && process.env.PATHEXT) {
|
||
|
|
for (const extension of process.env.PATHEXT.split(path.delimiter)) {
|
||
|
|
if (extension) {
|
||
|
|
extensions.push(extension);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// if it's rooted, return it if exists. otherwise return empty.
|
||
|
|
if (ioUtil.isRooted(tool)) {
|
||
|
|
const filePath = yield ioUtil.tryGetExecutablePath(tool, extensions);
|
||
|
|
if (filePath) {
|
||
|
|
return filePath;
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
// if any path separators, return empty
|
||
|
|
if (tool.includes('/') || (ioUtil.IS_WINDOWS && tool.includes('\\'))) {
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
// build the list of directories
|
||
|
|
//
|
||
|
|
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
|
||
|
|
// it feels like we should not do this. Checking the current directory seems like more of a use
|
||
|
|
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
|
||
|
|
// across platforms.
|
||
|
|
const directories = [];
|
||
|
|
if (process.env.PATH) {
|
||
|
|
for (const p of process.env.PATH.split(path.delimiter)) {
|
||
|
|
if (p) {
|
||
|
|
directories.push(p);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// return the first match
|
||
|
|
for (const directory of directories) {
|
||
|
|
const filePath = yield ioUtil.tryGetExecutablePath(directory + path.sep + tool, extensions);
|
||
|
|
if (filePath) {
|
||
|
|
return filePath;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return '';
|
||
|
|
}
|
||
|
|
catch (err) {
|
||
|
|
throw new Error(`which failed with message ${err.message}`);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
exports.which = which;
|
||
|
|
function readCopyOptions(options) {
|
||
|
|
const force = options.force == null ? true : options.force;
|
||
|
|
const recursive = Boolean(options.recursive);
|
||
|
|
return { force, recursive };
|
||
|
|
}
|
||
|
|
function cpDirRecursive(sourceDir, destDir, currentDepth, force) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
// Ensure there is not a run away recursive copy
|
||
|
|
if (currentDepth >= 255)
|
||
|
|
return;
|
||
|
|
currentDepth++;
|
||
|
|
yield mkdirP(destDir);
|
||
|
|
const files = yield ioUtil.readdir(sourceDir);
|
||
|
|
for (const fileName of files) {
|
||
|
|
const srcFile = `${sourceDir}/${fileName}`;
|
||
|
|
const destFile = `${destDir}/${fileName}`;
|
||
|
|
const srcFileStat = yield ioUtil.lstat(srcFile);
|
||
|
|
if (srcFileStat.isDirectory()) {
|
||
|
|
// Recurse
|
||
|
|
yield cpDirRecursive(srcFile, destFile, currentDepth, force);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
yield copyFile(srcFile, destFile, force);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Change the mode for the newly created directory
|
||
|
|
yield ioUtil.chmod(destDir, (yield ioUtil.stat(sourceDir)).mode);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
// Buffered file copy
|
||
|
|
function copyFile(srcFile, destFile, force) {
|
||
|
|
return __awaiter(this, void 0, void 0, function* () {
|
||
|
|
if ((yield ioUtil.lstat(srcFile)).isSymbolicLink()) {
|
||
|
|
// unlink/re-link it
|
||
|
|
try {
|
||
|
|
yield ioUtil.lstat(destFile);
|
||
|
|
yield ioUtil.unlink(destFile);
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
// Try to override file permission
|
||
|
|
if (e.code === 'EPERM') {
|
||
|
|
yield ioUtil.chmod(destFile, '0666');
|
||
|
|
yield ioUtil.unlink(destFile);
|
||
|
|
}
|
||
|
|
// other errors = it doesn't exist, no work to do
|
||
|
|
}
|
||
|
|
// Copy over symlink
|
||
|
|
const symlinkFull = yield ioUtil.readlink(srcFile);
|
||
|
|
yield ioUtil.symlink(symlinkFull, destFile, ioUtil.IS_WINDOWS ? 'junction' : null);
|
||
|
|
}
|
||
|
|
else if (!(yield ioUtil.exists(destFile)) || force) {
|
||
|
|
yield ioUtil.copyFile(srcFile, destFile);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
//# sourceMappingURL=io.js.map
|