crossbow/dist/file.utils.js

"use strict";
var task_utils_1 = require("./task.utils");
var fs_1 = require("fs");
var path_1 = require("path");
var fs_2 = require("fs");
var path_2 = require("path");
var fs_3 = require("fs");
var Rx = require("rx");
var path_3 = require("path");
var fs_4 = require("fs");
var crypto_1 = require("crypto");
var fs_5 = require("fs");
var hd = require("hash-dir");
var hashDirAsObservable = Rx.Observable.fromNodeCallback(hd);
var hashFileAsObservable = Rx.Observable.fromNodeCallback(hashFile);
var lstatAsObservable = Rx.Observable.fromNodeCallback(fs_5.lstat);
var _ = require("../lodash.custom");
// todo windows support for .bat files etc
var supportedTaskFileExtensions = [".js", ".sh"];
/**
 * Try to auto-load configuration files
 * from the users CWD
 */
function retrieveDefaultInputFiles(config) {
    var defaultConfigFiles = ["crossbow.yaml", "crossbow.js", "crossbow.yml", "crossbow.json"];
    return readInputFiles(defaultConfigFiles, config.cwd);
}
exports.retrieveDefaultInputFiles = retrieveDefaultInputFiles;
/**
 * Try to load cbfiles (like gulp) from the users
 * working directory
 * @param config
 * @returns {InputFiles}
 */
function retrieveCBFiles(config) {
    var defaultCBFiles = ["cbfile.js", "crossbowfile.js"];
    var maybes = (function () {
        if (config.cbfile) {
            return [config.cbfile];
        }
        return defaultCBFiles;
    })();
    return readInputFiles(maybes, config.cwd);
}
exports.retrieveCBFiles = retrieveCBFiles;
/**
 * Try to retrieve input files from disk.
 * This is different from regular file reading as
 * we deliver errors with context
 */
function readInputFiles(paths, cwd) {
    /**
     * Get files that exist on disk
     * @type {ExternalFile[]}
     */
    var inputFiles = readFilesFromDisk(paths, cwd);
    /**
     * Add parsed input keys to them
     * @type {}
     */
    var inputs = inputFiles.map(function (inputFile) {
        /**
         * If the file does not exist, change the error to be an InputFileNotFound error
         * as this will allow more descriptive logging when needed
         */
        if (inputFile.errors.length) {
            return _.assign({}, inputFile, {
                // here there may be any types of file error,
                // but we only care that was an error, and normalise it
                // here for logging. We can added nice per-error messages later.
                errors: [{ type: task_utils_1.InputErrorTypes.InputFileNotFound }],
                input: undefined
            });
        }
        /**
         * If the input file was yaml, load it & translate to JS
         */
        if (inputFile.parsed.ext.match(/ya?ml$/i)) {
            var yml = require("js-yaml");
            try {
                return _.assign(inputFile, {
                    input: yml.safeLoad(fs_1.readFileSync(inputFile.resolved, "utf8"))
                });
            }
            catch (e) {
                return _.assign(inputFile, {
                    input: undefined,
                    errors: [{ type: task_utils_1.InputErrorTypes.InvalidYaml, error: e }]
                });
            }
        }
        /**
         * Finally assume a JS/JSON file and 'require' it as normal
         */
        try {
            return _.assign({}, inputFile, {
                input: require(inputFile.resolved)
            });
        }
        catch (e) {
            return _.assign(inputFile, {
                input: undefined,
                errors: [{ type: task_utils_1.InputErrorTypes.InvalidInput, error: e }]
            });
        }
    });
    return {
        all: inputs,
        valid: inputs.filter(function (x) { return x.errors.length === 0; }),
        invalid: inputs.filter(function (x) { return x.errors.length > 0; })
    };
}
exports.readInputFiles = readInputFiles;
function readFilesFromDiskWithContent(paths, cwd) {
    var files = readFilesFromDisk(paths, cwd);
    return files
        .map(function (x) {
        if (x.errors.length)
            return x;
        x.content = fs_1.readFileSync(x.resolved, "utf8");
        return x;
    });
}
exports.readFilesFromDiskWithContent = readFilesFromDiskWithContent;
function readFileContent(file) {
    return fs_1.readFileSync(file.resolved, "utf8");
}
exports.readFileContent = readFileContent;
function writeFileToDisk(file, content) {
    var mkdirp = require("mkdirp").sync;
    mkdirp(path_3.dirname(file.resolved));
    fs_1.writeFileSync(file.resolved, content);
}
exports.writeFileToDisk = writeFileToDisk;
function getStubFileWithContent(path, cwd) {
    var file = getStubFile(path, cwd);
    file.content = "";
    return file;
}
exports.getStubFileWithContent = getStubFileWithContent;
function readOrCreateJsonFile(path, cwd) {
    var existing = readFilesFromDiskWithContent([path], cwd)[0];
    if (existing.errors.length) {
        if (existing.errors[0].type === task_utils_1.InputErrorTypes.FileNotFound) {
            var stub = getStubFileWithContent(path, cwd);
            stub.content = "{}";
            stub.data = JSON.parse(stub.content);
            return stub;
        }
    }
    else {
        try {
            existing.data = JSON.parse(existing.content);
        }
        catch (e) {
            existing.data = {};
        }
    }
    return existing;
}
exports.readOrCreateJsonFile = readOrCreateJsonFile;
function getStubFile(path, cwd) {
    var resolved = path_1.resolve(cwd, path);
    return {
        errors: [],
        rawInput: path,
        resolved: resolved,
        parsed: path_1.parse(resolved),
        relative: path_1.relative(cwd, resolved)
    };
}
exports.getStubFile = getStubFile;
/**
 * Take an array of paths and return file info + errors if they don't exist
 * @param paths
 * @param cwd
 * @returns {ExternalFile[]}
 */
function readFilesFromDisk(paths, cwd) {
    return paths
        .map(String)
        .map(function (x) { return getStubFile(x, cwd); })
        .map(function (incoming) {
        var resolved = incoming.resolved;
        /**
         * If the path does not exist, it's a FileNotFound error
         */
        if (!fs_1.existsSync(resolved)) {
            return _.assign(incoming, {
                errors: [{ type: task_utils_1.InputErrorTypes.FileNotFound }]
            });
        }
        /**
         * Not check it's a file & NOT a dir
         * @type {Stats}
         */
        var stat = fs_2.statSync(resolved);
        if (!stat.isFile()) {
            return _.assign(incoming, {
                errors: [{ type: task_utils_1.InputErrorTypes.NotAFile }],
            });
        }
        /**
         * At this point the file DOES exist
         */
        return incoming;
    });
}
exports.readFilesFromDisk = readFilesFromDisk;
/**
 * Attempt to use the LOCALLY installed crossbow version
 * first, this will ensure anything registered with .task etc
 * can be picked up by global installs too.
 * @param config
 * @returns {InputFiles}
 */
function getRequirePaths(config) {
    var local = path_2.join("node_modules", "crossbow", "dist", "public", "create.js");
    var global = path_2.join(__dirname, "public", "create.js");
    return readInputFiles([local, global], config.cwd);
}
exports.getRequirePaths = getRequirePaths;
function getExternalFiles(dirpaths, cwd) {
    return dirpaths
        .map(function (dirpath) {
        return path_1.resolve(cwd, dirpath);
    })
        .filter(fs_1.existsSync)
        .reduce(function (acc, dirPath) {
        return acc.concat(fs_3.readdirSync(dirPath).map(function (filepath) {
            var resolved = path_2.join(dirPath, filepath);
            var parsed = path_1.parse(resolved);
            var output = {
                rawInput: filepath,
                resolved: resolved,
                relative: path_1.relative(cwd, resolved),
                parsed: parsed,
                errors: []
            };
            return output;
        }));
    }, []);
}
exports.getExternalFiles = getExternalFiles;
function getPossibleTasksFromDirectories(dirpaths, cwd) {
    return getExternalFiles(dirpaths, cwd)
        .filter(function (x) { return supportedTaskFileExtensions.indexOf(x.parsed.ext) > -1; })
        .map(function (x) {
        return x.relative;
    });
}
exports.getPossibleTasksFromDirectories = getPossibleTasksFromDirectories;
(function (HashDirErrorTypes) {
    HashDirErrorTypes[HashDirErrorTypes["HashNotADirectory"] = "HashNotADirectory"] = "HashNotADirectory";
    HashDirErrorTypes[HashDirErrorTypes["HashPathNotFound"] = "HashPathNotFound"] = "HashPathNotFound";
})(exports.HashDirErrorTypes || (exports.HashDirErrorTypes = {}));
var HashDirErrorTypes = exports.HashDirErrorTypes;
function hashItems(dirs, cwd, existingHashes) {
    return Rx.Observable
        .from(dirs)
        .map(function (x) {
        return {
            userInput: x,
            pathObj: getStubFile(x, cwd)
        };
    })
        .distinct(function (x) { return x.pathObj.resolved; })
        .flatMap(hashFileOrDir)
        .toArray()
        .map(function (x) {
        return markHashes(x, existingHashes);
    });
}
exports.hashItems = hashItems;
function hashFile(filepath, fn) {
    var hash = crypto_1.createHash("sha256");
    fs_4.createReadStream(filepath)
        .on("data", function (chunk) {
        hash.update(chunk);
    })
        .on("end", function () {
        fn(null, hash.digest("hex"));
    })
        .on("error", fn);
}
function hashFileOrDir(input) {
    return lstatAsObservable(input.pathObj.resolved).flatMap(function (stats) {
        if (stats.isDirectory()) {
            return hashDirAsObservable(input.pathObj.resolved).map(function (tree) {
                return {
                    userInput: input.userInput,
                    resolved: input.pathObj.resolved,
                    hash: tree.hash
                };
            });
        }
        if (stats.isFile()) {
            return hashFileAsObservable(input.pathObj.resolved).map(function (hash) {
                return {
                    userInput: input.userInput,
                    resolved: input.pathObj.resolved,
                    hash: hash
                };
            });
        }
        return Rx.Observable.empty();
    });
}
function markHashes(newHashes, existingHashes) {
    var newHashPaths = newHashes.map(function (x) { return x.resolved; });
    var markedHashes = newHashes.map(function (newHash) {
        var match = existingHashes.filter(function (x) { return x.resolved === newHash.resolved; });
        newHash.changed = (function () {
            if (match.length) {
                return match[0].hash !== newHash.hash;
            }
            return true; // return true by default so that new entries always run
        })();
        return newHash;
    });
    var otherHashes = existingHashes.filter(function (hash) {
        return newHashPaths.indexOf(hash.resolved) === -1;
    });
    var output = otherHashes.concat(newHashes).filter(Boolean);
    return {
        output: output,
        markedHashes: markedHashes
    };
}
var binDirectoryExists = function (path) {
    return fs_1.existsSync(path)
        ? exports.Right(path)
        : exports.Left({ type: task_utils_1.InputErrorTypes.BinDirectoryNotFound });
};
var isDirectory = function (path) {
    return fs_2.statSync(path).isDirectory()
        ? exports.Right(path)
        : exports.Left({ type: task_utils_1.InputErrorTypes.BinPathNotADirectory });
};
var joinPath = function (path, cwd) { return exports.Right(path_2.join(cwd, path)); };
exports.getBinLookup = function (path, cwd) {
    return joinPath(String(path), cwd)
        .chain(function (resolved) { return exports.Right(resolved)
        .chain(function (resolved) { return binDirectoryExists(resolved); })
        .chain(function (resolved) { return isDirectory(resolved); })
        .fold(function (error) {
        return {
            errors: [error],
            resolved: resolved,
            input: path
        };
    }, function (resolved) {
        return {
            errors: [],
            resolved: resolved,
            input: path
        };
    }); });
};
exports.getBinLookups = function (paths, cwd) {
    return exports.Right([].concat(paths).map(function (path) { return exports.getBinLookup(path, cwd); }))
        .chain(function (xs) {
        return {
            all: xs,
            valid: xs.filter(function (x) { return x.errors.length === 0; }),
            invalid: xs.filter(function (x) { return x.errors.length > 0; })
        };
    });
};
exports.Right = function (x) { return ({
    chain: function (f) { return f(x); },
    map: function (f) { return exports.Right(f(x)); },
    fold: function (f, g) { return g(x); },
    inspect: function () { return ("Right(" + x + ")"); }
}); };
exports.Left = function (x) { return ({
    chain: function (f) { return exports.Left(x); },
    map: function (f) { return exports.Left(x); },
    fold: function (f, g) { return f(x); },
    inspect: function () { return ("Left(" + x + ")"); }
}); };
exports.tryCatch = function (f) {
    try {
        return exports.Right(f());
    }
    catch (e) {
        return exports.Left(e);
    }
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.utils.js","sourceRoot":"","sources":["../src/file.utils.ts"],"names":[],"mappings":"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"}