'use strict';

// Imports

const childProcess = require('child_process');

const fs = require('fs');

const path = require('path');

// Variables - Private

const exec = childProcess.exec;

const spawn = childProcess.spawn;

// Exports

module.exports = {

copyContent,

createDir,

execAsPromised,

finallyAsPromised,

getExecutable,

keepOnly,

killProcess,

removeDir,

removeFile,

replaceInFile,

spawnAsPromised,

traverseDir

};

// Functions - Definitions

function copyContent(srcDir, dstDir, notIgnoreHidden) {

return traverseDir(srcDir, fileCallback, {pre: dirCallback});

// Helpers

function dirCallback(dirPath) {

return (!notIgnoreHidden && isHidden(dirPath)) ?

Promise.resolve(true) :

createDir(dirPath.replace(srcDir, dstDir));

}

function fileCallback(filePath) {

return (!notIgnoreHidden && isHidden(filePath)) ?

Promise.resolve() :

new Promise((resolve, reject) => {

const dstPath = filePath.replace(srcDir, dstDir);

fs.readFile(filePath, (err, data) => {

if (err) return reject(err);

fs.writeFile(dstPath, data, err => err ? reject(err) : resolve());

});

});

}

}

function createDir(dir, failIfExists) {

return new Promise((resolve, reject) => {

fs.mkdir(dir, err => {

if (err && (failIfExists || (err.code !== 'EEXIST'))) reject(err);

resolve();

});

});

}

function execAsPromised(cmd, options) {

let proc;

const promise = new Promise((resolve, reject) => {

proc = exec(cmd, options, (err, stdout) => {

if (err) return reject(err);

resolve(stdout);

});

});

promise.$$process = proc;

return promise;

}

function finallyAsPromised(promise, callback) {

return promise.then(runCallback('resolve'), runCallback('reject'));

// Helpers

function runCallback(returnMethod) {

return arg => {

const onDone = () => Promise[returnMethod](arg);

return Promise.resolve(callback()).then(onDone, onDone);

};

}

}

function getExecutable(name, isGlobal) {

const suffix = isWindows() ? '.cmd' : '';

const prefix = isGlobal ? '' : path.join('node_modules', '.bin');

return `${path.join(prefix, name)}${suffix}`;

}

function ignoreMissing(err) {

if (err.code === 'ENOENT') {

console.warn(`Ignoring error: ${err}\n ${err.stack || ''}`);

return Promise.resolve();

}

return Promise.reject(err);

}

function isHidden(fileOrDir) {

return path.basename(fileOrDir)[0] === '.';

}

function isWindows() {

return process.platform === 'win32';

}

function keepOnly(fileOrDir, notIgnoreHidden) {

return new Promise((resolve, reject) => {

const absPath = path.resolve(fileOrDir);

const parentDir = path.dirname(absPath);

fs.readdir(parentDir, (err, items) => {

if (err) return reject(err);

let itemsToRemove = items.filter(item => path.resolve(item) !== absPath);

if (!notIgnoreHidden) itemsToRemove = itemsToRemove.filter(item => !isHidden(item));

Promise.

all(itemsToRemove.map(item => new Promise((resolve, reject) => {

fs.lstat(item, (err, stat) => {

if (err) return ignoreMissing(err).then(resolve, reject);

const promise = stat.isDirectory() ? removeDir(item) : removeFile(item);

promise.catch(ignoreMissing).then(resolve, reject);

});

}))).

then(resolve, reject);

});

});

}

function killProcess(proc) {

const pid = proc.pid;

const cmd = (isWindows() ? 'taskkill /t /f /pid ' : 'kill ') + pid;

return spawnAsPromised(cmd);

}

function replaceInFile(valuePlaceholderMap, filePath) {

return new Promise((resolve, reject) => {

fs.readFile(filePath, 'utf-8', (err, text) => {

if (err) return reject(err);

const newText = Object.

keys(valuePlaceholderMap).

reduce((text, value) => text.replace(valuePlaceholderMap[value], value), text);

fs.writeFile(filePath, newText, err => err ? reject(err) : resolve());

});

});

}

function removeDir(dir) {

return traverseDir(dir, removeFile, removeEmptyDir, ignoreMissing).

catch(ignoreMissing);

// Helpers

function removeEmptyDir(emptyDir) {

return new Promise((resolve, reject) => {

fs.rmdir(emptyDir, err => err ? reject(err) : resolve());

});

}

}

function removeFile(file) {

return new Promise((resolve, reject) => {

fs.unlink(file, err => err ? reject(err) : resolve());

});

}

function spawnAsPromised(cmd, options) {

let proc;

const promise = new Promise((resolve, reject) => {

const parsedCmd = parseCmd(cmd);

const executable = parsedCmd.executable;

const args = parsedCmd.args;

options = options || {stdio: 'inherit'};

proc = spawn(executable, args, options).

on('error', reject).

on('exit', (code, signal) => (code !== 0) ? reject(code || signal) : resolve());

});

promise.$$process = proc;

return promise;

// Helpers

function parseCmd(cmd) {

const tokens = Array.isArray(cmd) ? cmd : cmd.

split('"').

reduce((arr, str, idx) => arr.concat((idx % 2) ? `"${str}"` : str.split(' ')), []).

filter(Boolean);

return {

executable: tokens[0],

args: tokens.slice(1)

};

}

}

function traverseDir(dir, fileCallback, dirCallback, errInterceptor) {

const resolve = () => Promise.resolve();

const reject = err => Promise.reject(err);

if (!errInterceptor) errInterceptor = reject;

dirCallback = {

pre: dirCallback.pre || resolve,

post: (typeof dirCallback === 'function') ? dirCallback : (dirCallback.post || resolve)

};

return dirCallback.pre(dir).

then(skip => skip ? Promise.resolve() : new Promise((resolve, reject) => {

fs.readdir(dir, (err, items) => {

if (err) return errInterceptor(err).then(resolve, reject);

Promise.

all(items.map(item => new Promise((resolve, reject) => {

const curPath = path.join(dir, item);

fs.lstat(curPath, (err, stat) => {

if (err) return errInterceptor(err).then(resolve, reject);

const promise = stat.isDirectory() ?

traverseDir(curPath, fileCallback, dirCallback, errInterceptor) :

fileCallback(curPath);

promise.

catch(errInterceptor).

then(resolve, reject);

});

}))).

then(resolve, reject);

});

})).

then(() => dirCallback.post(dir));

}