"use strict";
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
};
|
Object.defineProperty(exports, "__esModule", { value: true });
|
// @flow
|
const chalk_1 = __importDefault(require("chalk"));
|
const fs_1 = __importDefault(require("fs"));
|
const lodash_padend_1 = __importDefault(require("lodash.padend"));
|
const microcli_1 = __importDefault(require("microcli"));
|
// @ts-ignore
|
const omelette_1 = __importDefault(require("omelette"));
|
const path_1 = __importDefault(require("path"));
|
const CLIError = microcli_1.default.CliError;
|
const common_1 = require("./common");
|
const DEFAULT_RUNFILE_PATH = "./runfile.js";
|
function requirer(filePath) {
|
return require(path_1.default.resolve(filePath));
|
}
|
exports.requirer = requirer;
|
function hasAccess(filePath) {
|
return fs_1.default.accessSync(path_1.default.resolve(filePath));
|
}
|
exports.hasAccess = hasAccess;
|
function getConfig(filePath) {
|
let config;
|
try {
|
config = requirer(filePath).runjs || {};
|
}
|
catch (error) {
|
config = {};
|
}
|
return config;
|
}
|
exports.getConfig = getConfig;
|
function load(config, logger, requirer, access) {
|
const runfilePath = config.runfile || DEFAULT_RUNFILE_PATH;
|
// Load requires if given in config
|
if (Array.isArray(config.requires)) {
|
config.requires.forEach(modulePath => {
|
logger.log(chalk_1.default.gray(`Requiring ${modulePath}...`));
|
requirer(modulePath);
|
});
|
}
|
// Process runfile
|
logger.log(chalk_1.default.gray(`Processing ${runfilePath}...`));
|
try {
|
access(runfilePath);
|
}
|
catch (error) {
|
throw new common_1.RunJSError(`No ${runfilePath} defined in ${process.cwd()}`);
|
}
|
const runfile = requirer(runfilePath);
|
if (runfile.default) {
|
return runfile.default;
|
}
|
return runfile;
|
}
|
exports.load = load;
|
function describe(obj, logger, namespace) {
|
if (!namespace) {
|
logger.log(chalk_1.default.yellow("Available tasks:"));
|
}
|
Object.keys(obj).forEach(key => {
|
const value = obj[key];
|
const nextNamespace = namespace ? `${namespace}:${key}` : key;
|
const help = value.help;
|
if (typeof value === "function") {
|
// Add task name
|
const funcParams = help && help.params;
|
const logArgs = [chalk_1.default.bold(nextNamespace)];
|
// Add task params
|
if (Array.isArray(funcParams) && funcParams.length) {
|
logArgs[0] += ` [${funcParams.join(" ")}]`;
|
}
|
// Add description
|
if (help && (help.description || typeof help === "string")) {
|
const description = help.description || help;
|
logArgs[0] = lodash_padend_1.default(logArgs[0], 40); // format
|
logArgs.push("-", description.split("\n")[0]);
|
}
|
// Log
|
logger.log(...logArgs);
|
}
|
else if (typeof value === "object") {
|
describe(value, logger, nextNamespace);
|
}
|
});
|
if (!namespace) {
|
logger.log("\n" +
|
chalk_1.default.blue('Type "run [taskname] --help" to get more info if available.'));
|
}
|
}
|
exports.describe = describe;
|
function tasks(obj, namespace) {
|
let list = [];
|
Object.keys(obj).forEach(key => {
|
const value = obj[key];
|
const nextNamespace = namespace ? `${namespace}:${key}` : key;
|
if (typeof value === "function") {
|
list.push(nextNamespace);
|
}
|
else if (typeof value === "object") {
|
list = list.concat(tasks(value, nextNamespace));
|
}
|
});
|
return list;
|
}
|
function call(obj, args, logger, subtaskName) {
|
const taskName = subtaskName || args[2];
|
if (typeof obj[taskName] === "function") {
|
const cli = microcli_1.default(args.slice(1), obj[taskName].help, undefined, logger);
|
cli((options, ...params) => {
|
obj[taskName].apply({ options }, params);
|
});
|
return obj[taskName];
|
}
|
const namespaces = taskName.split(":");
|
const rootNamespace = namespaces.shift() || "";
|
const nextSubtaskName = namespaces.join(":");
|
if (obj[rootNamespace]) {
|
const calledTask = call(obj[rootNamespace], args, logger, nextSubtaskName);
|
if (calledTask) {
|
return calledTask;
|
}
|
}
|
if (!subtaskName) {
|
throw new common_1.RunJSError(`Task ${taskName} not found`);
|
}
|
}
|
exports.call = call;
|
function autocomplete(config) {
|
const logger = new common_1.SilentLogger();
|
const completion = omelette_1.default("run <task>");
|
completion.on("task", ({ reply }) => {
|
const runfile = load(config, logger, requirer, hasAccess);
|
reply(tasks(runfile));
|
});
|
completion.init();
|
}
|
function main() {
|
try {
|
const config = getConfig("./package.json");
|
autocomplete(config);
|
const runfile = load(config, common_1.logger, requirer, hasAccess);
|
const ARGV = process.argv.slice();
|
if (ARGV.length > 2) {
|
call(runfile, ARGV, common_1.logger);
|
}
|
else {
|
describe(runfile, common_1.logger);
|
}
|
}
|
catch (error) {
|
if (error instanceof common_1.RunJSError || error instanceof CLIError) {
|
common_1.logger.error(error.message);
|
process.exit(1);
|
}
|
else {
|
common_1.logger.log(error);
|
process.exit(1);
|
}
|
}
|
}
|
exports.main = main;
|
//# sourceMappingURL=script.js.map
|
