tortilla/dist/utils.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var ChildProcess = require("child_process");
var events_1 = require("events");
var Fs = require("fs-extra");
var path_1 = require("path");
/**
 Contains general utilities.
 */
var cwdReturnValue;
var git;
var npm;
var node;
function init() {
    // Defaults to process's current working dir
    cwdReturnValue = process.env.TORTILLA_CWD || process.cwd();
    try {
        cwdReturnValue = ChildProcess.execFileSync('git', [
            'rev-parse', '--show-toplevel',
        ], {
            cwd: cwdReturnValue,
            stdio: ['pipe', 'pipe', 'ignore'],
        }).toString()
            .trim();
    }
    catch (err) {
        // If no git-exists nor git-failed use default value instead
    }
    // Setting all relative utils
    exec.print = spawn;
    git = exec.bind(null, 'git');
    git.print = spawn.bind(null, 'git');
    npm = exec.bind(null, 'npm');
    npm.print = spawn.bind(null, 'npm');
    node = exec.bind(null, 'node');
    node.print = spawn.bind(null, 'node');
}
init();
function cwd() {
    return cwdReturnValue;
}
// Checks if one of the parent processes launched by the provided file and has
// the provided arguments
function isChildProcessOf(file, argv, offset) {
    // There might be nested processes of the same file so we wanna go through all of them,
    // This variable represents how much skips will be done anytime the file is found.
    var trial = offset = offset || 0;
    // The current process would be the node's
    var currProcess = {
        file: process.title,
        pid: process.pid,
        argv: process.argv,
    };
    // Will abort once the file is found and there are no more skips left to be done
    while (currProcess.file !== file || trial--) {
        // Get the parent process id
        currProcess.pid = Number(getProcessData(currProcess.pid, 'ppid'));
        // The root process'es id is 0 which means we've reached the limit
        if (!currProcess.pid) {
            return false;
        }
        currProcess.argv = getProcessData(currProcess.pid, 'command')
            .split(' ')
            .filter(Boolean);
        // The first word in the command would be the file name
        currProcess.file = currProcess.argv[0];
        // The rest would be the arguments vector
        currProcess.argv = currProcess.argv.slice(1);
    }
    // Make sure it has the provided arguments
    var result = argv.every(function (arg) { return currProcess.argv.indexOf(arg) !== -1; });
    // If this is not the file we're looking for keep going up in the processes tree
    return result || isChildProcessOf(file, argv, ++offset);
}
// Gets process data using 'ps' formatting
function getProcessData(pid, format) {
    if (arguments.length === 1) {
        format = pid;
        pid = process.pid;
    }
    var result = exec('ps', ['-p', pid, '-o', format]).split('\n');
    result.shift();
    return result.join('\n');
}
// Spawn new process and print result to the terminal
function spawn(file, argv, options) {
    argv = argv || [];
    options = extend({
        cwd: process.env.TORTILLA_CWD || cwd(),
        stdio: process.env.TORTILLA_STDIO || 'inherit',
        env: {},
    }, options);
    var envRedundantKeys = Object.keys(options.env).filter(function (key) {
        return options.env[key] == null;
    });
    options.env = extend({
        TORTILLA_CHILD_PROCESS: true,
    }, process.env, options.env);
    envRedundantKeys.forEach(function (key) {
        delete options.env[key];
    });
    return ChildProcess.spawnSync(file, argv, options);
}
// Execute file
function exec(file, argv, options) {
    argv = argv || [];
    options = extend({
        cwd: process.env.TORTILLA_CWD || cwd(),
        stdio: 'pipe',
        env: {},
    }, options);
    var envRedundantKeys = Object.keys(options.env).filter(function (key) {
        return options.env[key] == null;
    });
    options.env = __assign({ TORTILLA_CHILD_PROCESS: true }, process.env, options.env);
    envRedundantKeys.forEach(function (key) {
        delete options.env[key];
    });
    debug("Executing (execFileSync) command \"" + file + " " + argv.join(' ') + "\" (" + options.cwd + ")");
    var out = ChildProcess.execFileSync(file, argv, options);
    // In case of stdio inherit
    if (!out) {
        return '';
    }
    return out.toString().trim();
}
function inspect(str, argv) {
    if (argv === void 0) { argv = []; }
    return spawn('less', argv, {
        input: str,
        stdio: ['pipe', 'inherit', 'inherit']
    });
}
// Tells if entity exists or not by an optional document type
function exists(path, type) {
    try {
        var stats = Fs.lstatSync(path);
        switch (type) {
            case 'dir':
                return stats.isDirectory();
            case 'file':
                return stats.isFile();
            case 'symlink':
                return stats.isSymbolicLink();
            default:
                return true;
        }
    }
    catch (err) {
        return false;
    }
}
// Create a temporary scope which will define provided variables on the environment
function scopeEnv(fn, env) {
    var keys = Object.keys(env);
    var originalEnv = pluck(process.env, keys);
    var nullKeys = keys.filter(function (key) { return process.env[key] == null; });
    extend(process.env, env);
    try {
        return fn();
    }
    finally {
        extend(process.env, originalEnv);
        contract(process.env, nullKeys);
    }
}
// Filter all strings matching the provided pattern in an array
function filterMatches(arr, pattern) {
    pattern = pattern || '';
    return arr.filter(function (str) { return str.match(pattern); });
}
// Deeply merges destination object with source object
function merge(destination, source) {
    if (!(destination instanceof Object) ||
        !(source instanceof Object)) {
        return source;
    }
    Object.keys(source).forEach(function (k) {
        destination[k] = merge(destination[k], source[k]);
    });
    return destination;
}
// Extend destination object with provided sources
function extend(destination) {
    var sources = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        sources[_i - 1] = arguments[_i];
    }
    sources.forEach(function (source) {
        if (!(source instanceof Object)) {
            return;
        }
        Object.keys(source).forEach(function (k) {
            destination[k] = source[k];
        });
    });
    return destination;
}
// Deletes all keys in the provided object
function contract(destination, keys) {
    keys.forEach(function (key) {
        delete destination[key];
    });
    return destination;
}
// Plucks all keys from object
function pluck(obj, keys) {
    return keys.reduce(function (result, key) {
        result[key] = obj[key];
        return result;
    }, {});
}
// Pad the provided string with the provided pad params from the left
// '1' -> '00001'
function pad(str, length, char) {
    str = str.toString();
    char = char || ' ';
    var chars = Array(length + 1).join(char);
    return chars.substr(0, chars.length - str.length) + str;
}
// Like pad() only from the right
// '1' -> '10000'
function padRight(str, length, char) {
    str = str.toString();
    char = char || ' ';
    var chars = Array(length + 1).join(char);
    return str + chars.substr(0, chars.length - str.length);
}
// foo_barBaz -> foo-bar-baz
function toKebabCase(str) {
    return splitWords(str)
        .map(lowerFirst)
        .join('-');
}
// foo_barBaz -> Foo Bar Baz
function toStartCase(str) {
    return splitWords(str)
        .map(upperFirst)
        .join(' ');
}
// Lower -> lower
function lowerFirst(str) {
    return str.substr(0, 1).toLowerCase() + str.substr(1);
}
// upper -> Upper
function upperFirst(str) {
    return str.substr(0, 1).toUpperCase() + str.substr(1);
}
// foo_barBaz -> ['foo', 'bar', 'Baz']
function splitWords(str) {
    return str
        .replace(/[A-Z]/, ' $&')
        .split(/[^a-zA-Z0-9]+/);
}
// Wraps source descriptors and defines them on destination. The modifiers object
// contains the wrappers for the new descriptors, and has 3 properties:
// - value - A value wrapper, if function
// - get - A getter wrapper
// - set - A setter wrapper
// All 3 wrappers are called with 3 arguments: handler, propertyName, args
function delegateProperties(destination, source, modifiers) {
    Object.getOwnPropertyNames(source).forEach(function (propertyName) {
        var propertyDescriptor = Object.getOwnPropertyDescriptor(source, propertyName);
        if (typeof propertyDescriptor.value === 'function' && modifiers.value) {
            var superValue_1 = propertyDescriptor.value;
            propertyDescriptor.value = function () {
                var args = [].slice.call(arguments);
                return modifiers.value.call(this, superValue_1, propertyName, args);
            };
        }
        else {
            if (propertyDescriptor.get && modifiers.get) {
                var superGetter_1 = propertyDescriptor.get;
                propertyDescriptor.get = function () {
                    return modifiers.get.call(this, superGetter_1, propertyName);
                };
            }
            if (propertyDescriptor.set && modifiers.set) {
                var superGetter_2 = propertyDescriptor.set;
                propertyDescriptor.set = function (value) {
                    return modifiers.value.call(this, superGetter_2, propertyName, value);
                };
            }
        }
        Object.defineProperty(destination, propertyName, propertyDescriptor);
    });
    return destination;
}
function isEqual(objA, objB) {
    if (objA === objB) {
        return true;
    }
    if (typeof objA !== typeof objB) {
        return false;
    }
    if (!(objA instanceof Object) || !(objB instanceof Object)) {
        return false;
    }
    if (objA.__proto__ !== objB.__proto__) {
        return false;
    }
    var objAKeys = Object.keys(objA);
    var objBKeys = Object.keys(objB);
    if (objAKeys.length !== objBKeys.length) {
        return;
    }
    objAKeys.sort();
    objBKeys.sort();
    return objAKeys.every(function (keyA, index) {
        var keyB = objBKeys[index];
        if (keyA !== keyB) {
            return false;
        }
        var valueA = objA[keyA];
        var valueB = objB[keyB];
        return isEqual(valueA, valueB);
    });
}
function escapeBrackets(str) {
    return str
        .replace(/\(/g, '\\(')
        .replace(/\)/g, '\\)')
        .replace(/\[/g, '\\[')
        .replace(/\]/g, '\\]')
        .replace(/\{/g, '\\{')
        .replace(/\}/g, '\\}')
        .replace(/\</g, '\\<')
        .replace(/\>/g, '\\>');
}
// Takes a shell script string and transforms it into a one liner
function shCmd(cmd) {
    return cmd
        .trim()
        .replace(/\n+/g, ';')
        .replace(/\s+/g, ' ')
        .replace(/then\s*;/g, 'then')
        .replace(/else\s*;/g, 'else')
        .replace(/;\s*;/g, ';')
        .trim();
}
function naturalSort(as, bs) {
    var a1;
    var b1;
    var i = 0;
    var n;
    var rx = /(\.\d+)|(\d+(\.\d+)?)|([^\d.]+)|(\.\D+)|(\.$)/g;
    if (as === bs) {
        return 0;
    }
    var a = as.toLowerCase().match(rx);
    var b = bs.toLowerCase().match(rx);
    var L = a.length;
    while (i < L) {
        if (!b[i]) {
            return 1;
        }
        a1 = a[i];
        b1 = b[i++];
        if (a1 !== b1) {
            n = a1 - b1;
            if (!isNaN(n)) {
                return n;
            }
            return a1 > b1 ? 1 : -1;
        }
    }
    return b[i] ? -1 : 0;
}
// Temporarily changes CWD for child_process and then restores it at the end
// of the execution. Useful for submodules. Will emit a 'cwdChange' event once
// it happens to do so
function setTempCwd(callback, tempCwd) {
    tempCwd = path_1.resolve(cwd(), tempCwd);
    var result = scopeEnv(function () {
        init();
        exports.Utils.emit('cwdChange', tempCwd);
        return callback();
    }, {
        TORTILLA_CWD: tempCwd
    });
    init();
    exports.Utils.emit('cwdChange', cwdReturnValue);
    return result;
}
// Will use the shortest indention as an axis
exports.freeText = function (text) {
    if (text instanceof Array) {
        text = text.join('');
    }
    // This will allow inline text generation with external functions, same as ctrl+shift+c
    // As long as we surround the inline text with ==>text<==
    text = text.replace(/( *)==>((?:.|\n)*?)<==/g, function (match, baseIndent, content) {
        return content
            .split('\n')
            .map(function (line) { return "" + baseIndent + line; })
            .join('\n');
    });
    var lines = text.split('\n');
    var minIndent = lines.filter(function (line) { return line.trim(); }).reduce(function (soFar, line) {
        var currIndent = line.match(/^ */)[0].length;
        return currIndent < soFar ? currIndent : soFar;
    }, Infinity);
    return lines
        .map(function (line) { return line.slice(minIndent); })
        .join('\n')
        .trim()
        .replace(/\n +\n/g, '\n\n');
};
function log() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    console.log.apply(console, args);
}
function debug() {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    if (process.env.DEBUG) {
        console.log.apply(console, args);
    }
}
exports.Utils = Object.assign(new events_1.EventEmitter(), {
    cwd: cwd,
    exec: exec,
    inspect: inspect,
    git: git,
    npm: npm,
    childProcessOf: isChildProcessOf,
    exists: exists,
    scopeEnv: scopeEnv,
    filterMatches: filterMatches,
    merge: merge,
    extend: extend,
    contract: contract,
    pluck: pluck,
    pad: pad,
    padRight: padRight,
    kebabCase: toKebabCase,
    startCase: toStartCase,
    lowerFirst: lowerFirst,
    upperFirst: upperFirst,
    words: splitWords,
    delegateProperties: delegateProperties,
    isEqual: isEqual,
    escapeBrackets: escapeBrackets,
    shCmd: shCmd,
    naturalSort: naturalSort,
    tempCwd: setTempCwd,
    freeText: exports.freeText,
    log: log,
    debug: debug,
});
//# sourceMappingURL=utils.js.map