menhera-cli/dist/cli.js

#!/usr/bin/env node
'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var parser = _interopDefault(require('yargs-parser'));
var Menehra = require('menhera');
var Menehra__default = _interopDefault(Menehra);
var chalk = _interopDefault(require('chalk'));
var dowloadRepo = _interopDefault(require('download-git-repo'));
var fs = _interopDefault(require('fs-extra'));
var cliSpinner = _interopDefault(require('cli-spinners'));
var ora = _interopDefault(require('ora'));
var path = _interopDefault(require('path'));
var Message = _interopDefault(require('menhera-message'));

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function _objectWithoutProperties(source, excluded) {
  if (source == null) return {};
  var target = {};
  var sourceKeys = Object.keys(source);
  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {
    key = sourceKeys[i];
    if (excluded.indexOf(key) >= 0) continue;
    target[key] = source[key];
  }

  if (Object.getOwnPropertySymbols) {
    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

    for (i = 0; i < sourceSymbolKeys.length; i++) {
      key = sourceSymbolKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
      target[key] = source[key];
    }
  }

  return target;
}

function _toArray(arr) {
  return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest();
}

function _arrayWithHoles(arr) {
  if (Array.isArray(arr)) return arr;
}

function _iterableToArray(iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
}

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance");
}

var space = function space(num) {
  return Array.from(new Array(num)).join(" ");
};
var fillSpace = function fillSpace(size, current) {
  return space(size - current);
};
var genOutput = function genOutput(_ref) {
  var input = _ref.input,
      chalkFn = _ref.chalkFn,
      length = _ref.length,
      _ref$left = _ref.left,
      left = _ref$left === void 0 ? 0 : _ref$left,
      _ref$right = _ref.right,
      right = _ref$right === void 0 ? 0 : _ref$right;
  var inputLenght = input.length;
  var output = chalkFn(input);
  (!length || inputLenght > length) && (length = inputLenght);
  return "".concat(space(left)).concat(output || []).concat(fillSpace(length, inputLenght)).concat(space(right));
};
var ENV = function ENV(_ref2) {
  var _args = _ref2._args,
      args = _ref2.args,
      options = _ref2.options;
  var env = {};
  env.NONE_ARGS = args.length === 0;
  env.NONE_OPTIONS = Object.keys(options).length === 0;
  env.NONE_INPUTS = env.NONE_ARGS && env.NONE_OPTIONS;
  env.NONE_FULL_ARGS = _args.length !== args.length;
  return env;
};

var commands = {
  $: function $(_ref) {
    var _this = this;

    var _ = _ref._,
        _key = _ref._key,
        _val = _ref._val,
        cp = _ref.cp;
    var commandAlias = this.alias.commands,
        rootAlias = this.config.rootAlias;
    var name = _val.name,
        _val$args = _val.args,
        args = _val$args === void 0 ? [] : _val$args,
        alias = _val.alias,
        _val$examples = _val.examples,
        examples = _val$examples === void 0 ? {} : _val$examples,
        _val$desc = _val.desc,
        cDesc = _val$desc === void 0 ? "" : _val$desc,
        _val$options = _val.options,
        options = _val$options === void 0 ? {} : _val$options;
    var key = name || _key;
    this.commands[key] = _val;

    if (alias) {
      this.alias.commands[key] = alias;
      this.alias.commands[alias] = key;
    }

    examples && Menehra.$set(this.examples, examples);
    var commandOutput = [];
    args = args.map(function (argv) {
      return "[".concat(argv, "]");
    });

    if (key !== rootAlias) {
      commandOutput.push("".concat(genOutput({
        input: "".concat(key),
        chalkFn: chalk.magenta,
        length: 12,
        left: 2
      })).concat(genOutput({
        input: "".concat(alias || ""),
        chalkFn: chalk.magenta,
        length: 6
      })).concat(genOutput({
        input: "".concat(args.join(" ")),
        chalkFn: chalk.grey,
        length: 50
      })).concat(genOutput({
        input: "".concat(cDesc),
        chalkFn: chalk.grey,
        length: 20
      }), "\n"));
    }

    var examplesOutput = [];

    Menehra.$(examples, function (key, val) {
      examplesOutput.push("".concat(genOutput({
        input: "".concat(key),
        chalkFn: chalk.magenta,
        length: 20,
        left: 2
      })).concat(genOutput({
        input: "".concat(val),
        chalkFn: chalk.grey,
        length: 50
      }), "\n"));
    });

    var optionOutput = [];

    Menehra.$(options, function (key, val) {
      var alias = val.alias,
          oDesc = val.desc;
      _this.alias.options[key] = alias;
      _this.alias.options[alias] = key;
      optionOutput.push("".concat(genOutput({
        input: "-".concat(alias),
        chalkFn: chalk.grey,
        length: 6,
        left: 12
      })).concat(genOutput({
        input: "--".concat(key),
        chalkFn: chalk.grey,
        length: 50
      })).concat(genOutput({
        input: oDesc,
        chalkFn: chalk.grey,
        length: 10
      }), "\n"));
    });

    Menehra.$set(this.helper, _defineProperty({}, key, {
      examplesOutput: examplesOutput,
      optionOutput: optionOutput,
      commandOutput: commandOutput
    }));
  }
};
var config = {
  _: function _(_ref2) {
    var _2 = _ref2._,
        _val = _ref2._val;
    Menehra.$set(this.config, _val);
  },
  start: function start(_ref3) {
    var _this2 = this;

    var _ = _ref3._,
        _val = _ref3._val;
    var _this$alias = this.alias,
        optionAlias = _this$alias.options,
        commandAlias = _this$alias.commands,
        _this$config = this.config,
        name = _this$config.name,
        target = _this$config.target,
        rootAlias = _this$config.rootAlias,
        version = _this$config.version;

    var _parser = parser(target || process.argv.slice(2)),
        __ = _parser._,
        options = _objectWithoutProperties(_parser, ["_"]);

    var _3 = _toArray(__),
        _$2 = _3[0],
        _key = _$2 === void 0 ? rootAlias : _$2,
        args = _3.slice(1);

    var command = this.commands[_key] || this.commands[commandAlias[_key]] || {};

    var _command$args = command.args,
        _args = _command$args === void 0 ? [] : _command$args,
        _command$exec = command.exec,
        exec = _command$exec === void 0 ? function () {} : _command$exec,
        _command$options = command.options,
        _options = _command$options === void 0 ? {} : _command$options;

    Menehra.$(_options, function (key, val) {
      var _default = _options[key].default;
      _this2.args[key] = _default;
      var alias = optionAlias[key];
      alias && (_this2.args[alias] = _default);
    });

    Menehra.$(options, function (key, val) {
      _this2.args[key] = val;
      var alias = optionAlias[key];
      alias && (_this2.args[alias] = val);
    });

    Menehra.$(_args, function (i, argv) {
      _this2.args[argv] = args[i];
    });

    Menehra.$(args, function (i) {
      _this2.args["$".concat(i)] = args[i];
    });

    var val = Object.assign({
      _: _,
      CLI: this
    }, this.args, {
      _key: _key,
      options: options,
      args: args,
      _args: _args
    });
    val.env = ENV(val);
    var help = val.help,
        v = val.v;

    if (help) {
      _.$use(_defineProperty({}, "".concat(name, ".help"), _key));

      return;
    }

    if (v) {
      console.log(version);
      return;
    }

    exec(val);
  }
};
function help(_ref4) {
  var _val = _ref4._val;
  var help;
  var commandAlias = this.alias.commands,
      rootAlias = this.config.rootAlias;

  if (_val !== rootAlias) {
    help = this.helper[_val] || this.helper[commandAlias[_val]];
  } else {
    help = {
      commandOutput: Object.values(this.helper).map(function (help) {
        return help.commandOutput;
      }),
      optionOutput: this.helper[rootAlias].optionOutput
    };
  }

  if (!help) return;
  console.log("\n\n".concat(chalk.grey("Commands:"), "\n\n").concat(help.commandOutput.join(""), "\n\n").concat(chalk.grey("Options:"), "\n\n").concat(help.optionOutput.join(""), "\n    "));
}
function usage(_ref5) {
  var _val = _ref5._val;
  var commandAlias = this.alias.commands;
  var help = this.helper[_val] || this.helper[commandAlias[_val]];
  help && console.log(" \n  \n".concat(chalk.grey("Usage:"), "\n              \n").concat(help.commandOutput.join(""), "\n    "));
}
function examples(_ref6) {
  var _val = _ref6._val;
  var rootAlias = this.config.rootAlias;
  help = {
    examplesOutput: Object.values(this.helper).map(function (help) {
      return help.examplesOutput.join("");
    })
  };
  console.log("\n\n".concat(chalk.grey("Examples:"), "\n              \n").concat(help.examplesOutput.join(""), "\n  "));
}

var CLI = /*#__PURE__*/Object.freeze({
  commands: commands,
  config: config,
  get help () { return help; },
  usage: usage,
  examples: examples
});

var examples$1 = {
  desc: "Examples",
  alias: "e",
  args: ["example"],
  exec: function exec(data) {
    return new Promise(function ($return, $error) {
      var _ = data._,
          env = data.env,
          example = data.example,
          CLI = data.CLI;
      var _CLI$config = CLI.config,
          name = _CLI$config.name,
          rootAlias = _CLI$config.rootAlias,
          examples = CLI.examples;

      if (env.NONE_INPUTS) {
        _.$use(_defineProperty({}, "".concat(name, ".examples"), rootAlias));

        return $return();
      }

      var val = examples[example];
      var target = val.split(" ");

      _.$use({
        CLI: {
          config: {
            target: target,
            start: true
          }
        }
      });

      return $return();
    });
  }
};

var commands$1 = /*#__PURE__*/Object.freeze({
  examples: examples$1
});

var CLI$1 = (function (_ref) {
  var name = _ref.name,
      version = _ref.version;
  return _defineProperty({
    name: name,
    alias: {
      options: {
        help: "h",
        h: "help",
        version: "v",
        v: "version"
      },
      commands: {
        examples: "e",
        e: "examples"
      }
    },
    args: {},
    commands: {},
    examples: {},
    helper: {},
    _hooks: _defineProperty({}, name, CLI),
    config: {
      name: name,
      version: version,
      rootAlias: "_"
    }
  }, name, {
    commands: commands$1
  });
});

var download = function download(repo, desc, options) {
  return new Promise(function (res, rej) {
    dowloadRepo(repo, desc, options, function (err) {
      err ? rej(err) : res(err);
    });
  });
};
var forceDownload = function forceDownload(repo, desc, options) {
  return new Promise(function ($return, $error) {
    var exists;
    return Promise.resolve(fs.exists(desc)).then(function ($await_2) {
      try {
        exists = $await_2;

        if (exists) {
          return Promise.resolve(fs.remove(desc)).then(function ($await_3) {
            try {
              return $If_1.call(this);
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }

        function $If_1() {
          return Promise.resolve(download(repo, desc, options)).then($return, $error);
        }

        return $If_1.call(this);
      } catch ($boundEx) {
        return $error($boundEx);
      }
    }.bind(this), $error);
  });
};
var RandomKeyFromObject = function RandomKeyFromObject(object) {
  return object[RandomKeyFromArray(Object.keys(object))];
};
var RandomKeyFromArray = function RandomKeyFromArray(array) {
  return array[Math.floor(Math.random() * array.length)];
};

var download$1 = {
  fail: function fail() {
    return console.log("\n\nsorry, download failed. \n      ");
  },
  success: function success(_ref) {
    var _ref$_val = _ref._val,
        projectName = _ref$_val.projectName,
        templateName = _ref$_val.templateName;
    return console.log(chalk.green("\nSuccess! Created <".concat(projectName, "> with template <").concat(templateName, ">\n\nWe suggest that you begin by typing:\n\n  $ cd ").concat(projectName, "\n  $ yarn install\n\n  Happy hacking!\n")));
  }
};
var colors = ["black", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray"];
var _spinner = null;
var spinner = function spinner(_ref2) {
  var _key = _ref2._key,
      _val = _ref2._val;
  var mode = _val.mode,
      type = _val.type,
      text = _val.text,
      color = _val.color,
      status = _val.status;

  if (status == "stop") {
    if (_spinner) {
      _spinner.stop();
    }
  }

  if (status == "start") {
    var args = {};

    if (mode === "random") {
      var randomSpinner = RandomKeyFromObject(cliSpinner);

      var _color = RandomKeyFromArray(colors);

      args.spinner = randomSpinner;
      args.color = _color;
    }

    color && (args.color = color);
    text && (args.text = text);
    cliSpinner[type] && (args.spinner = cliSpinner[type]);
    _spinner = new ora(args);

    _spinner.start();
  }
};

var messages = /*#__PURE__*/Object.freeze({
  download: download$1,
  spinner: spinner
});

var _ = {
  exec: function exec(_ref) {
    var _ = _ref._,
        _key = _ref._key,
        env = _ref.env;

    if (env.NONE_INPUTS) {
      _.$use({
        Mhr: {
          help: _key
        }
      });
    }
  }
};
var init = {
  desc: "Init Project",
  alias: "i",
  args: ["templateName", "projectName"],
  examples: {
    "init:cli": "init uu-z/template-cli mycli",
    "init:module": "init uu-z/template-module mymodule"
  },
  options: {
    clone: {
      alias: "c",
      desc: "clone repo",
      default: false
    }
  },
  exec: function exec(data) {
    return new Promise(function ($return, $error) {
      var _, _key, templateName, projectName, clone, h, env, desc, download$$1;

      _ = data._, _key = data._key, templateName = data.templateName, projectName = data.projectName, clone = data.clone, h = data.h, env = data.env;

      if (env.NONE_INPUTS) {
        _.$use({
          Mhr: {
            help: _key
          }
        });

        return $return();
      }

      if (env.NONE_FULL_ARGS) {
        _.$use({
          Mhr: {
            usage: _key
          }
        });

        return $return();
      }

      desc = path.join(process.cwd(), projectName);

      _.$use({
        Message: {
          spinner: {
            mode: "random",
            text: "downloading...",
            status: "start"
          }
        }
      });

      download$$1 = {};
      return Promise.resolve(forceDownload(templateName, desc, {
        clone: clone
      })).then(function ($await_1) {
        try {
          $await_1 ? download$$1.fail = true : download$$1.success = {
            templateName: templateName,
            projectName: projectName
          };

          _.$use({
            Message: {
              download: download$$1,
              spinner: {
                status: "stop"
              }
            }
          });

          return $return();
        } catch ($boundEx) {
          return $error($boundEx);
        }
      }, $error);
    });
  }
};

var commands$2 = /*#__PURE__*/Object.freeze({
  _: _,
  init: init
});

var Mhr = CLI$1({
  name: "Mhr",
  version: "0.0.1"
});
var cli = Menehra__default.$use({
  _mount: {
    Mhr: Mhr,
    Message: Message
  },
  messages: messages,
  Mhr: {
    commands: commands$2,
    config: {
      start: true
    }
  }
});

module.exports = cli;