fscr 5.4.0 → 6.1.1

package/dist/lib/run/parse-cli-args.js

@@ -0,0 +1,222 @@
+/**
+ * @author Toru Nagashima
+ * @copyright 2016 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict";
+
+/*eslint-disable no-process-env */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+const OVERWRITE_OPTION = /^--([^:]+?):([^=]+?)(?:=(.+))?$/;
+const CONFIG_OPTION = /^--([^=]+?)(?:=(.+))$/;
+const PACKAGE_CONFIG_PATTERN = /^npm_package_config_(.+)$/;
+const CONCAT_OPTIONS = /^-[clnprs]+$/;
+
+/**
+ * Overwrites a specified package config.
+ *
+ * @param {object} config - A config object to be overwritten.
+ * @param {string} packageName - A package name to overwrite.
+ * @param {string} variable - A variable name to overwrite.
+ * @param {string} value - A new value to overwrite.
+ * @returns {void}
+ */
+function overwriteConfig(config, packageName, variable, value) {
+  const scope = config[packageName] || (config[packageName] = {});
+  scope[variable] = value;
+}
+
+/**
+ * Creates a package config object.
+ * This checks `process.env` and creates the default value.
+ *
+ * @returns {object} Created config object.
+ */
+function createPackageConfig() {
+  const retv = {};
+  const packageName = process.env.npm_package_name;
+  if (!packageName) {
+    return retv;
+  }
+  for (const key of Object.keys(process.env)) {
+    const m = PACKAGE_CONFIG_PATTERN.exec(key);
+    if (m != null) {
+      overwriteConfig(retv, packageName, m[1], process.env[key]);
+    }
+  }
+  return retv;
+}
+
+/**
+ * Adds a new group into a given list.
+ *
+ * @param {object[]} groups - A group list to add.
+ * @param {object} initialValues - A key-value map for the default of new value.
+ * @returns {void}
+ */
+function addGroup(groups, initialValues) {
+  groups.push(Object.assign({
+    parallel: false,
+    patterns: []
+  }, initialValues || {}));
+}
+
+/**
+ * ArgumentSet is values of parsed CLI arguments.
+ * This class provides the getter to get the last group.
+ */
+class ArgumentSet {
+  /**
+   * @param {object} initialValues - A key-value map for the default of new value.
+   * @param {object} options - A key-value map for the options.
+   */
+  constructor(initialValues, options) {
+    this.config = {};
+    this.continueOnError = false;
+    this.groups = [];
+    this.maxParallel = 0;
+    this.npmPath = null;
+    this.packageConfig = createPackageConfig();
+    this.printLabel = false;
+    this.printName = false;
+    this.race = false;
+    this.rest = [];
+    this.silent = process.env.npm_config_loglevel === "silent";
+    this.singleMode = Boolean(options && options.singleMode);
+    addGroup(this.groups, initialValues);
+  }
+
+  /**
+   * Gets the last group.
+   */
+  get lastGroup() {
+    return this.groups[this.groups.length - 1];
+  }
+
+  /**
+   * Gets "parallel" flag.
+   */
+  get parallel() {
+    return this.groups.some(g => g.parallel);
+  }
+}
+
+/**
+ * Parses CLI arguments.
+ *
+ * @param {ArgumentSet} set - The parsed CLI arguments.
+ * @param {string[]} args - CLI arguments.
+ * @returns {ArgumentSet} set itself.
+ */
+function parseCLIArgsCore(set, args) {
+  // eslint-disable-line complexity
+  LOOP: for (let i = 0; i < args.length; ++i) {
+    const arg = args[i];
+    switch (arg) {
+      case "--":
+        set.rest = args.slice(1 + i);
+        break LOOP;
+      case "--color":
+      case "--no-color":
+        // do nothing.
+        break;
+      case "-c":
+      case "--continue-on-error":
+        set.continueOnError = true;
+        break;
+      case "-l":
+      case "--print-label":
+        set.printLabel = true;
+        break;
+      case "-n":
+      case "--print-name":
+        set.printName = true;
+        break;
+      case "-r":
+      case "--race":
+        set.race = true;
+        break;
+      case "--silent":
+        set.silent = true;
+        break;
+      case "--max-parallel":
+        set.maxParallel = parseInt(args[++i], 10);
+        if (!Number.isFinite(set.maxParallel) || set.maxParallel <= 0) {
+          throw new Error(`Invalid Option: --max-parallel ${args[i]}`);
+        }
+        break;
+      case "-s":
+      case "--sequential":
+      case "--serial":
+        if (set.singleMode && arg === "-s") {
+          set.silent = true;
+          break;
+        }
+        if (set.singleMode) {
+          throw new Error(`Invalid Option: ${arg}`);
+        }
+        addGroup(set.groups);
+        break;
+      case "--aggregate-output":
+        set.aggregateOutput = true;
+        break;
+      case "-p":
+      case "--parallel":
+        if (set.singleMode) {
+          throw new Error(`Invalid Option: ${arg}`);
+        }
+        addGroup(set.groups, {
+          parallel: true
+        });
+        break;
+      case "--npm-path":
+        set.npmPath = args[++i] || null;
+        break;
+      default:
+        {
+          let matched = null;
+          if (matched = OVERWRITE_OPTION.exec(arg)) {
+            overwriteConfig(set.packageConfig, matched[1], matched[2], matched[3] || args[++i]);
+          } else if (matched = CONFIG_OPTION.exec(arg)) {
+            set.config[matched[1]] = matched[2];
+          } else if (CONCAT_OPTIONS.test(arg)) {
+            parseCLIArgsCore(set, arg.slice(1).split("").map(c => `-${c}`));
+          } else if (arg[0] === "-") {
+            throw new Error(`Invalid Option: ${arg}`);
+          } else {
+            set.lastGroup.patterns.push(arg);
+          }
+          break;
+        }
+    }
+  }
+  if (!set.parallel && set.aggregateOutput) {
+    throw new Error("Invalid Option: --aggregate-output (without parallel)");
+  }
+  if (!set.parallel && set.race) {
+    const race = args.indexOf("--race") !== -1 ? "--race" : "-r";
+    throw new Error(`Invalid Option: ${race} (without parallel)`);
+  }
+  if (!set.parallel && set.maxParallel !== 0) {
+    throw new Error("Invalid Option: --max-parallel (without parallel)");
+  }
+  return set;
+}
+
+/**
+ * Parses CLI arguments.
+ *
+ * @param {string[]} args - CLI arguments.
+ * @param {object} initialValues - A key-value map for the default of new value.
+ * @param {object} options - A key-value map for the options.
+ * @param {boolean} options.singleMode - The flag to be single group mode.
+ * @returns {ArgumentSet} The parsed CLI arguments.
+ */
+module.exports = function parseCLIArgs(args, initialValues, options) {
+  return parseCLIArgsCore(new ArgumentSet(initialValues, options), args);
+};
+
+/*eslint-enable */

package/dist/lib/run/run-p.js

@@ -0,0 +1,30 @@
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+/*eslint-disable no-process-exit */
+
+function bootstrap(name) {
+  const argv = process.argv.slice(2);
+  switch (argv[0]) {
+    case undefined:
+    default:
+      // https://github.com/mysticatea/npm-run-all/issues/105
+      // Avoid MaxListenersExceededWarnings.
+      process.stdout.setMaxListeners(0);
+      process.stderr.setMaxListeners(0);
+      process.stdin.setMaxListeners(0);
+
+      // Main
+      return import("./main-p.js").then(mod => mod.default(argv, process.stdout, process.stderr)).then(() => {
+        // I'm not sure why, but maybe the process never exits
+        // on Git Bash (MINGW64)
+        process.exit(0);
+      }, () => {
+        process.exit(1);
+      });
+  }
+}
+
+/*eslint-enable */
+
+bootstrap("run-p");

package/dist/lib/run/run-s.js

@@ -0,0 +1,57 @@
+/**
+ * @author Toru Nagashima
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Main
+//------------------------------------------------------------------------------
+/**
+ * @author Toru Nagashima
+ * @copyright 2016 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function printVersion(output) {
+  const version = JSON.parse(readFileSync(path.resolve(__dirname, "../../package.json"), "utf-8")).version;
+  output.write(`v${version}\n`);
+  return Promise.resolve(null);
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+/*eslint-disable no-process-exit */
+function bootstrap(name) {
+  const argv = process.argv.slice(2);
+  switch (argv[0]) {
+    case undefined:
+    case "-v":
+    case "--version":
+      return printVersion(process.stdout);
+    default:
+      // https://github.com/mysticatea/npm-run-all/issues/105
+      // Avoid MaxListenersExceededWarnings.
+      process.stdout.setMaxListeners(0);
+      process.stderr.setMaxListeners(0);
+      process.stdin.setMaxListeners(0);
+
+      // Main
+      return import(`./main-s.js`).then(mod => mod.default(argv, process.stdout, process.stderr)).then(() => {
+        // I'm not sure why, but maybe the process never exits
+        // on Git Bash (MINGW64)
+        process.exit(0);
+      }, () => {
+        process.exit(1);
+      });
+  }
+}
+
+/*eslint-enable */
+bootstrap("run-s");

package/dist/lib/runCLICommand.js

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+import path from "path";
+import moment from "moment-mini";
+import spawn from "cross-spawn";
+export default async ({
+  script,
+  task,
+  type = script.type
+}, quiet = false) => {
+  if (!quiet) {
+    console.log(`${chalk.green.bgHex("#181c24").bold("[" + moment().format("HH:MM:SS") + "]")}${chalk.bgHex("#181c24").bold.hex("#8c91a7")(" " + task.name + ": ")}`);
+  }
+  return new Promise(resolve => {
+    const cmd = spawn(type, [...script.rest], {
+      stdio: "inherit",
+      env: Object.assign({}, process.env, {
+        FORCE_COLOR: true,
+        PATH: `${path.resolve("node_modules/.bin")}:${process.env.PATH}`,
+        ...script.env
+      })
+    });
+    cmd.on("close", code => {
+      if (code === 0) {
+        resolve();
+      } else {
+        console.error(`${chalk.red("ERROR")} ${code}`);
+      }
+    });
+  });
+};

package/dist/lib/runParallel.js

@@ -0,0 +1,20 @@
+import runCLICommand from "./running/runCLICommand.js";
+const runParallel = async (tasks, FcScripts) => {
+  for (let t in tasks) {
+    let taskName = tasks[t];
+    let taskIndex = FcScripts.allTasks.findIndex(t => t.name === taskName);
+    let script = FcScripts.allTasks[taskIndex].script;
+    let params = script.split(" ");
+    let type = params.shift();
+    runCLICommand({
+      task: {
+        name: taskName
+      },
+      script: {
+        type: type,
+        rest: params
+      }
+    });
+  }
+};
+export default runParallel;

package/dist/lib/runSequence.js

@@ -0,0 +1,38 @@
+import runCLICommand from "./running/runCLICommand.js";
+import chalk from "chalk";
+const runSequence = async (tasks, FcScripts) => {
+  for (let t in tasks) {
+    let taskName = tasks[t];
+    let taskIndex = FcScripts.allTasks.findIndex(t => t.name === taskName);
+    if (taskIndex === -1) {
+      console.log(`${chalk.red.underline("Skipping task " + taskName + ", as it cannot be found in .md file")}`);
+    } else {
+      let script = FcScripts.allTasks[taskIndex].script;
+      let pars = script.split(" ");
+      let type = pars[0];
+      let env = {};
+      if (pars[0].includes("=")) {
+        let envs = type.split("=");
+        env[envs[0]] = envs[1];
+        type = pars[1];
+        pars.shift();
+        pars.shift();
+        script = pars.join(" ");
+      } else {
+        pars.shift();
+        script = pars.join(" ");
+      }
+      await runCLICommand({
+        task: {
+          name: taskName
+        },
+        script: {
+          type: type,
+          rest: script.split(" "),
+          env: env
+        }
+      });
+    }
+  }
+};
+export default runSequence;

package/dist/lib/running/index.js

@@ -0,0 +1,3 @@
+export { default as runSequence } from "./runSequence.js";
+export { default as runParallel } from "./runParallel.js";
+export { default as runCLICommand } from "./runCLICommand.js";

package/dist/lib/running/runCLICommand.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import path from "path";
+import moment from "moment-mini";
+import spawn from "cross-spawn";
+import requireFromString from "require-from-string";
+export default async ({
+  script,
+  task,
+  type = script.type
+}, quiet = false) => {
+  if (!quiet) {
+    console.log(`${chalk.green.bgHex("#181c24").bold("[" + moment().format("HH:MM:SS") + "]")}${chalk.bgHex("#181c24").bold.hex("#8c91a7")(" " + task.name + ": ")}`);
+  }
+  return new Promise(resolve => {
+    if (script.lang === "javascript") {
+      requireFromString(script.full, "./fscripts.md");
+      resolve();
+    } else {
+      const cmd = spawn(type, [...script.rest], {
+        stdio: "inherit",
+        env: Object.assign({}, process.env, {
+          FORCE_COLOR: true,
+          PATH: `${path.resolve("node_modules/.bin")}:${process.env.PATH}`,
+          ...script.env
+        })
+      });
+      cmd.on("close", code => {
+        if (code === 0) {
+          resolve();
+        } else {
+          console.error(`${chalk.red("ERROR")} ${code} runCli`);
+          resolve();
+        }
+      });
+      // }
+    }
+  });
+};

package/dist/lib/running/runParallel.js

@@ -0,0 +1,33 @@
+import runCLICommand from "./runCLICommand.js";
+import chalk from "chalk";
+const runParallel = async (tasks, FcScripts) => {
+  const promises = tasks.map(async taskName => {
+    return new Promise(async resolve => {
+      const taskData = FcScripts.allTasks.find(z => z.name === taskName);
+      if (!taskData) {
+        console.error(`${chalk.bold.underline.red("Task not found")}`);
+        resolve();
+      } else {
+        let {
+          script,
+          lang
+        } = taskData;
+        let type = script.split(" ");
+        await runCLICommand({
+          task: {
+            name: taskName
+          },
+          script: {
+            lang: lang,
+            type: type.shift(),
+            full: script,
+            rest: script.split(" ").slice(1)
+          }
+        });
+        resolve();
+      }
+    });
+  });
+  let results = await Promise.all(promises);
+};
+export default runParallel;

package/dist/lib/running/runSequence.js

@@ -0,0 +1,43 @@
+import runCLICommand from "./runCLICommand.js";
+import chalk from "chalk";
+const runSequence = async (tasks, FcScripts) => {
+  for (let t in tasks) {
+    let taskName = tasks[t];
+    const taskData = FcScripts.allTasks.find(z => z.name === taskName);
+    if (!taskData) {
+      console.error(`${chalk.bold.underline.red("Task not found")}`);
+    } else {
+      let {
+        script,
+        lang
+      } = taskData;
+      let pars = script.split(" ");
+      let type = pars[0];
+      let env = {};
+      if (pars[0].includes("=")) {
+        let envs = type.split("=");
+        env[envs[0]] = envs[1];
+        type = pars[1];
+        pars.shift();
+        pars.shift();
+        script = pars.join(" ");
+      } else {
+        pars.shift();
+        script = pars.join(" ");
+      }
+      await runCLICommand({
+        task: {
+          name: taskName
+        },
+        script: {
+          lang: lang,
+          env: env,
+          type: type,
+          full: script,
+          rest: script.split(" ")
+        }
+      });
+    }
+  }
+};
+export default runSequence;

package/dist/lib/startScripts.js

@@ -0,0 +1,135 @@
+import taskList from "./taskList.js";
+const separator = "   ~   ";
+import Conf from "conf";
+import moment from "moment-mini";
+import chalk from "chalk";
+import parseScriptFile from "./parsers/parseScriptsMd.js";
+import parsePackageFile from "./parsers/parseScriptsPackage.js";
+import runCLICommand from "./running/runCLICommand.js";
+import enquirerPkg from "enquirer";
+const {
+  prompt
+} = enquirerPkg;
+import path from "path";
+import fs from "fs";
+let packagePath = path.resolve(process.cwd(), "package.json");
+const packageJsonAfter = JSON.parse(fs.readFileSync(packagePath));
+console.info("Console --- packageJsonAfter.name", packageJsonAfter.name);
+const config = new Conf({
+  configName: packageJsonAfter.name
+});
+const taskListAutoComplete = async tasks => {
+  try {
+    let {
+      answer
+    } = await prompt({
+      type: "autocomplete",
+      message: `${chalk.green.bold.underline("Choose task to run")}`,
+      choices: tasks,
+      name: `answer`
+    });
+    return answer.split(separator)[0].trim();
+  } catch (e) {
+    return false;
+  }
+};
+const startScripts = async (categories = true) => {
+  const FcScripts = await parseScriptFile();
+  if (FcScripts === false) {
+    return false;
+  }
+  let recentTasks = config.get("recentTasks", {});
+  let recentTaskArr = Object.keys(recentTasks).map(taskName => {
+    let task = recentTasks[taskName];
+    return {
+      name: taskName,
+      lastExecuted: task.lastExecuted
+    };
+  }).sort((a, b) => a.lastExecuted > b.lastExecuted ? 1 : b.lastExecuted > a.lastExecuted ? -1 : 0).reverse().slice(0, 3);
+  let recentTaskOptions = recentTaskArr.map(task => {
+    return task.name + separator + moment(task.lastExecuted).calendar();
+  });
+  let taskToRun;
+  if (categories) {
+    taskToRun = await taskList(FcScripts, recentTaskOptions);
+  } else {
+    let tasks = FcScripts.allTasks;
+    taskToRun = await taskListAutoComplete(tasks.map(task => {
+      return `${task.name}${separator}${task.description}`;
+    }));
+  }
+  if (recentTasks[taskToRun] === undefined) {
+    recentTasks[taskToRun] = {
+      lastExecuted: Date.now()
+    };
+  } else {
+    recentTasks[taskToRun].lastExecuted = Date.now();
+  }
+  config.set("recentTasks", recentTasks);
+  const taskData = FcScripts.allTasks.find(t => t.name === taskToRun);
+  if (!taskData) {
+    console.error(`${chalk.bold.underline.red("Task not found")}`);
+    return;
+  }
+  let {
+    script,
+    lang
+  } = taskData;
+  let pars = script.split(" ");
+  let type = pars[0];
+  let env = {};
+  if (pars[0].includes("=")) {
+    let envs = type.split("=");
+    env[envs[0]] = envs[1];
+    type = pars[1];
+    pars.shift();
+    pars.shift();
+    script = pars.join(" ");
+  } else {
+    pars.shift();
+    script = pars.join(" ");
+  }
+  await runCLICommand({
+    task: {
+      name: taskToRun
+    },
+    script: {
+      lang: lang,
+      type: type,
+      env: env,
+      full: script,
+      rest: script.split(" ")
+    }
+  });
+};
+const startPackageScripts = async () => {
+  const packageScripts = await parsePackageFile();
+  let tasks = Object.keys(packageScripts).map(e => {
+    return {
+      name: e,
+      script: packageScripts[e]
+    };
+  });
+  let taskToRun = await taskListAutoComplete(tasks.map(task => {
+    return `${task.name}${separator}${task.script}`;
+  }));
+  if (taskToRun === false) {
+    console.log(chalk.green.bold("See you soon!"));
+    return false;
+  }
+  await runCLICommand({
+    task: {
+      name: taskToRun
+    },
+    script: {
+      lang: taskToRun.lang,
+      type: "yarn",
+      full: taskToRun.script,
+      rest: taskToRun.script.split(" ").slice(1)
+    }
+  });
+};
+const clearRecent = async () => {
+  config.set("recentTasks", {});
+};
+export { startScripts, taskListAutoComplete, clearRecent, startPackageScripts };