breadc 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,33 +1,284 @@
-import { blue, yellow, red } from 'kolorist';
+import { blue, yellow, red, gray } from 'kolorist';
 export { default as kolorist } from 'kolorist';
-import minimist from 'minimist';
-export { default as minimist } from 'minimist';
-import createDebug from 'debug';
-export { default as createDebug } from 'debug';
 
-function createDefaultLogger(name) {
-  const debug = createDebug(name + ":breadc");
-  return {
-    println(message) {
-      console.log(message);
-    },
-    info(message, ...args) {
-      console.log(`${blue("INFO")} ${message}`, ...args);
-    },
-    warn(message, ...args) {
-      console.log(`${yellow("WARN")} ${message}`, ...args);
-    },
-    error(message, ...args) {
-      console.log(`${red("ERROR")} ${message}`, ...args);
-    },
-    debug(message, ...args) {
-      debug(message, ...args);
+var minimist = function (args, opts) {
+    if (!opts) opts = {};
+    
+    var flags = { bools : {}, strings : {}, unknownFn: null };
+
+    if (typeof opts['unknown'] === 'function') {
+        flags.unknownFn = opts['unknown'];
+    }
+
+    if (typeof opts['boolean'] === 'boolean' && opts['boolean']) {
+      flags.allBools = true;
+    } else {
+      [].concat(opts['boolean']).filter(Boolean).forEach(function (key) {
+          flags.bools[key] = true;
+      });
+    }
+    
+    var aliases = {};
+    Object.keys(opts.alias || {}).forEach(function (key) {
+        aliases[key] = [].concat(opts.alias[key]);
+        aliases[key].forEach(function (x) {
+            aliases[x] = [key].concat(aliases[key].filter(function (y) {
+                return x !== y;
+            }));
+        });
+    });
+
+    [].concat(opts.string).filter(Boolean).forEach(function (key) {
+        flags.strings[key] = true;
+        if (aliases[key]) {
+            flags.strings[aliases[key]] = true;
+        }
+     });
+
+    var defaults = opts['default'] || {};
+    
+    var argv = { _ : [] };
+    Object.keys(flags.bools).forEach(function (key) {
+        setArg(key, defaults[key] === undefined ? false : defaults[key]);
+    });
+    
+    var notFlags = [];
+
+    if (args.indexOf('--') !== -1) {
+        notFlags = args.slice(args.indexOf('--')+1);
+        args = args.slice(0, args.indexOf('--'));
+    }
+
+    function argDefined(key, arg) {
+        return (flags.allBools && /^--[^=]+$/.test(arg)) ||
+            flags.strings[key] || flags.bools[key] || aliases[key];
+    }
+
+    function setArg (key, val, arg) {
+        if (arg && flags.unknownFn && !argDefined(key, arg)) {
+            if (flags.unknownFn(arg) === false) return;
+        }
+
+        var value = !flags.strings[key] && isNumber(val)
+            ? Number(val) : val
+        ;
+        setKey(argv, key.split('.'), value);
+        
+        (aliases[key] || []).forEach(function (x) {
+            setKey(argv, x.split('.'), value);
+        });
     }
+
+    function setKey (obj, keys, value) {
+        var o = obj;
+        for (var i = 0; i < keys.length-1; i++) {
+            var key = keys[i];
+            if (isConstructorOrProto(o, key)) return;
+            if (o[key] === undefined) o[key] = {};
+            if (o[key] === Object.prototype || o[key] === Number.prototype
+                || o[key] === String.prototype) o[key] = {};
+            if (o[key] === Array.prototype) o[key] = [];
+            o = o[key];
+        }
+
+        var key = keys[keys.length - 1];
+        if (isConstructorOrProto(o, key)) return;
+        if (o === Object.prototype || o === Number.prototype
+            || o === String.prototype) o = {};
+        if (o === Array.prototype) o = [];
+        if (o[key] === undefined || flags.bools[key] || typeof o[key] === 'boolean') {
+            o[key] = value;
+        }
+        else if (Array.isArray(o[key])) {
+            o[key].push(value);
+        }
+        else {
+            o[key] = [ o[key], value ];
+        }
+    }
+    
+    function aliasIsBoolean(key) {
+      return aliases[key].some(function (x) {
+          return flags.bools[x];
+      });
+    }
+
+    for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        
+        if (/^--.+=/.test(arg)) {
+            // Using [\s\S] instead of . because js doesn't support the
+            // 'dotall' regex modifier. See:
+            // http://stackoverflow.com/a/1068308/13216
+            var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
+            var key = m[1];
+            var value = m[2];
+            if (flags.bools[key]) {
+                value = value !== 'false';
+            }
+            setArg(key, value, arg);
+        }
+        else if (/^--no-.+/.test(arg)) {
+            var key = arg.match(/^--no-(.+)/)[1];
+            setArg(key, false, arg);
+        }
+        else if (/^--.+/.test(arg)) {
+            var key = arg.match(/^--(.+)/)[1];
+            var next = args[i + 1];
+            if (next !== undefined && !/^-/.test(next)
+            && !flags.bools[key]
+            && !flags.allBools
+            && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                setArg(key, next, arg);
+                i++;
+            }
+            else if (/^(true|false)$/.test(next)) {
+                setArg(key, next === 'true', arg);
+                i++;
+            }
+            else {
+                setArg(key, flags.strings[key] ? '' : true, arg);
+            }
+        }
+        else if (/^-[^-]+/.test(arg)) {
+            var letters = arg.slice(1,-1).split('');
+            
+            var broken = false;
+            for (var j = 0; j < letters.length; j++) {
+                var next = arg.slice(j+2);
+                
+                if (next === '-') {
+                    setArg(letters[j], next, arg);
+                    continue;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) {
+                    setArg(letters[j], next.split('=')[1], arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (/[A-Za-z]/.test(letters[j])
+                && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+                    setArg(letters[j], next, arg);
+                    broken = true;
+                    break;
+                }
+                
+                if (letters[j+1] && letters[j+1].match(/\W/)) {
+                    setArg(letters[j], arg.slice(j+2), arg);
+                    broken = true;
+                    break;
+                }
+                else {
+                    setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
+                }
+            }
+            
+            var key = arg.slice(-1)[0];
+            if (!broken && key !== '-') {
+                if (args[i+1] && !/^(-|--)[^-]/.test(args[i+1])
+                && !flags.bools[key]
+                && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+                    setArg(key, args[i+1], arg);
+                    i++;
+                }
+                else if (args[i+1] && /^(true|false)$/.test(args[i+1])) {
+                    setArg(key, args[i+1] === 'true', arg);
+                    i++;
+                }
+                else {
+                    setArg(key, flags.strings[key] ? '' : true, arg);
+                }
+            }
+        }
+        else {
+            if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+                argv._.push(
+                    flags.strings['_'] || !isNumber(arg) ? arg : Number(arg)
+                );
+            }
+            if (opts.stopEarly) {
+                argv._.push.apply(argv._, args.slice(i + 1));
+                break;
+            }
+        }
+    }
+    
+    Object.keys(defaults).forEach(function (key) {
+        if (!hasKey(argv, key.split('.'))) {
+            setKey(argv, key.split('.'), defaults[key]);
+            
+            (aliases[key] || []).forEach(function (x) {
+                setKey(argv, x.split('.'), defaults[key]);
+            });
+        }
+    });
+    
+    if (opts['--']) {
+        argv['--'] = new Array();
+        notFlags.forEach(function(key) {
+            argv['--'].push(key);
+        });
+    }
+    else {
+        notFlags.forEach(function(key) {
+            argv._.push(key);
+        });
+    }
+
+    return argv;
+};
+
+function hasKey (obj, keys) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        o = (o[key] || {});
+    });
+
+    var key = keys[keys.length - 1];
+    return key in o;
+}
+
+function isNumber (x) {
+    if (typeof x === 'number') return true;
+    if (/^0x[0-9a-f]+$/i.test(x)) return true;
+    return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+
+function isConstructorOrProto (obj, key) {
+    return key === 'constructor' && typeof obj[key] === 'function' || key === '__proto__';
+}
+
+function createDefaultLogger(name, logger) {
+  const println = !!logger && typeof logger === "function" ? logger : logger?.println ?? ((message, ...args) => {
+    console.log(message, ...args);
+  });
+  const info = typeof logger === "object" && logger?.info ? logger.info : (message, ...args) => {
+    println(`${blue("INFO")} ${message}`, ...args);
+  };
+  const warn = typeof logger === "object" && logger?.warn ? logger.warn : (message, ...args) => {
+    println(`${yellow("WARN")} ${message}`, ...args);
+  };
+  const error = typeof logger === "object" && logger?.error ? logger.error : (message, ...args) => {
+    println(`${red("ERROR")} ${message}`, ...args);
+  };
+  const debug = typeof logger === "object" && logger?.debug ? logger.debug : (message, ...args) => {
+    println(`${gray(name)} ${message}`, ...args);
+  };
+  return {
+    println,
+    info,
+    warn,
+    error,
+    debug
   };
 }
 
 const _Option = class {
   constructor(format, config = {}) {
+    this.format = format;
     const match = _Option.OptionRE.exec(format);
     if (match) {
       if (match[3]) {
@@ -43,25 +294,28 @@ const _Option = class {
       throw new Error(`Can not parse option format from "${format}"`);
     }
     this.description = config.description ?? "";
+    this.required = format.indexOf("<") !== -1;
+    this.default = config.default;
     this.construct = config.construct ?? ((text) => text ?? config.default ?? void 0);
   }
 };
 let Option = _Option;
 Option.OptionRE = /^(-[a-zA-Z], )?--([a-zA-Z.]+)( \[[a-zA-Z]+\]| <[a-zA-Z]+>)?$/;
 
-class Command {
+const _Command = class {
   constructor(format, config) {
     this.options = [];
     this.format = config.condition ? [format] : format.split(" ").map((t) => t.trim()).filter(Boolean);
+    this.default = this.format.length === 0 || this.format[0][0] === "[" || this.format[0][0] === "<";
     this.description = config.description ?? "";
     this.conditionFn = config.condition;
     this.logger = config.logger;
+    if (this.format.length > _Command.MaxDep) {
+      this.logger.warn(`Command format string "${format}" is too long`);
+    }
   }
   option(format, configOrDescription = "", otherConfig = {}) {
-    const config = otherConfig;
-    if (typeof configOrDescription === "string") {
-      config.description = configOrDescription;
-    }
+    const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     try {
       const option = new Option(format, config);
       this.options.push(option);
@@ -70,13 +324,18 @@ class Command {
     }
     return this;
   }
+  get hasConditionFn() {
+    return !!this.conditionFn;
+  }
   shouldRun(args) {
     if (this.conditionFn) {
       return this.conditionFn(args);
     } else {
-      const isArg = (t) => t[0] !== "[" && t[0] !== "<";
+      if (this.default)
+        return true;
+      const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
       for (let i = 0; i < this.format.length; i++) {
-        if (isArg(this.format[i])) {
+        if (!isCmd(this.format[i])) {
           return true;
         }
         if (i >= args["_"].length || this.format[i] !== args["_"][i]) {
@@ -86,7 +345,7 @@ class Command {
       return true;
     }
   }
-  parseArgs(args) {
+  parseArgs(args, globalOptions) {
     if (this.conditionFn) {
       const argumentss2 = args["_"];
       const options2 = args;
@@ -97,33 +356,55 @@ class Command {
         options: args
       };
     }
-    const isArg = (t) => t[0] !== "[" && t[0] !== "<";
+    const isCmd = (t) => t[0] !== "[" && t[0] !== "<";
     const argumentss = [];
     for (let i = 0; i < this.format.length; i++) {
-      if (isArg(this.format[i]))
+      if (isCmd(this.format[i]))
         continue;
       if (i < args["_"].length) {
         if (this.format[i].startsWith("[...")) {
-          argumentss.push(args["_"].slice(i));
+          argumentss.push(args["_"].slice(i).map(String));
         } else {
-          argumentss.push(args["_"][i]);
+          argumentss.push(String(args["_"][i]));
         }
       } else {
         if (this.format[i].startsWith("<")) {
+          this.logger.warn(`You should provide the argument "${this.format[i]}"`);
           argumentss.push(void 0);
         } else if (this.format[i].startsWith("[...")) {
           argumentss.push([]);
         } else if (this.format[i].startsWith("[")) {
           argumentss.push(void 0);
-        } else ;
+        } else {
+          this.logger.warn(`unknown format string ("${this.format[i]}")`);
+        }
       }
     }
+    const fullOptions = globalOptions.concat(this.options).reduce((map, o) => {
+      map.set(o.name, o);
+      return map;
+    }, /* @__PURE__ */ new Map());
     const options = args;
     delete options["_"];
+    for (const [name, rawOption] of fullOptions) {
+      if (rawOption.required) {
+        if (options[name] === void 0) {
+          options[name] = false;
+        } else if (options[name] === "") {
+          options[name] = true;
+        }
+      } else {
+        if (options[name] === false) {
+          options[name] = void 0;
+        } else if (!(name in options)) {
+          options[name] = void 0;
+        }
+      }
+    }
     return {
       command: this,
       arguments: argumentss,
-      options: args
+      options
     };
   }
   action(fn) {
@@ -131,17 +412,29 @@ class Command {
     return this;
   }
   async run(...args) {
-    this.actionFn && this.actionFn(...args);
+    if (this.actionFn) {
+      this.actionFn(...args);
+    } else {
+      this.logger.warn(`You may miss action function in "${this.format}"`);
+    }
   }
-}
-Command.MaxDep = 4;
-function createVersionCommand(breadc) {
+};
+let Command = _Command;
+Command.MaxDep = 5;
+function createHelpCommand(breadc) {
+  let helpCommand = void 0;
   return new Command("-h, --help", {
     condition(args) {
-      const isEmpty = !args["_"].length && !args["--"]?.length;
-      if (args.help && isEmpty) {
-        return true;
-      } else if (args.h && isEmpty) {
+      const isEmpty = !args["--"]?.length;
+      if ((args.help || args.h) && isEmpty) {
+        if (args["_"].length > 0) {
+          for (const cmd of breadc.commands) {
+            if (!cmd.hasConditionFn && !cmd.default && cmd.shouldRun(args)) {
+              helpCommand = cmd;
+              return true;
+            }
+          }
+        }
         return true;
       } else {
         return false;
@@ -149,10 +442,12 @@ function createVersionCommand(breadc) {
     },
     logger: breadc.logger
   }).action(() => {
-    breadc.logger.println("Help");
+    for (const line of breadc.help(helpCommand)) {
+      breadc.logger.println(line);
+    }
   });
 }
-function createHelpCommand(breadc) {
+function createVersionCommand(breadc) {
   return new Command("-v, --version", {
     condition(args) {
       const isEmpty = !args["_"].length && !args["--"]?.length;
@@ -166,7 +461,7 @@ function createHelpCommand(breadc) {
     },
     logger: breadc.logger
   }).action(() => {
-    breadc.logger.println(`${breadc.name}/${breadc.version}`);
+    breadc.logger.println(breadc.version());
   });
 }
 
@@ -175,22 +470,78 @@ class Breadc {
     this.options = [];
     this.commands = [];
     this.name = name;
-    this.version = option.version ?? "unknown";
-    this.logger = option.logger ?? createDefaultLogger(name);
+    this._version = option.version ?? "unknown";
+    this.description = option.description;
+    this.logger = createDefaultLogger(name, option.logger);
     const breadc = {
       name: this.name,
-      version: this.version,
+      version: () => this.version.call(this),
+      help: (command) => this.help.call(this, command),
       logger: this.logger,
       options: this.options,
       commands: this.commands
     };
-    this.commands = [createVersionCommand(breadc), createHelpCommand(breadc)];
+    this.commands.push(createVersionCommand(breadc), createHelpCommand(breadc));
   }
-  option(format, configOrDescription = "", otherConfig = {}) {
-    const config = otherConfig;
-    if (typeof configOrDescription === "string") {
-      config.description = configOrDescription;
+  version() {
+    return `${this.name}/${this._version}`;
+  }
+  help(command) {
+    const output = [];
+    const println = (msg) => output.push(msg);
+    println(this.version());
+    if (!command) {
+      if (this.description) {
+        println("");
+        if (Array.isArray(this.description)) {
+          for (const line of this.description) {
+            println(line);
+          }
+        } else {
+          println(this.description);
+        }
+      }
+    } else {
+      if (command.description) {
+        println("");
+        println(command.description);
+      }
+    }
+    if (!command) {
+      if (this.defaultCommand) {
+        println(``);
+        println(`Usage:`);
+        println(`  $ ${this.name} ${this.defaultCommand.format.join(" ")}`);
+      }
+    } else {
+      println(``);
+      println(`Usage:`);
+      println(`  $ ${this.name} ${command.format.join(" ")}`);
+    }
+    if (!command && this.commands.length > 2) {
+      println(``);
+      println(`Commands:`);
+      const commandHelps = this.commands.filter((c) => !c.hasConditionFn).map((c) => [`  $ ${this.name} ${c.format.join(" ")}`, c.description]);
+      for (const line of twoColumn(commandHelps)) {
+        println(line);
+      }
+    }
+    println(``);
+    println(`Options:`);
+    const optionHelps = [].concat([
+      ...command ? command.options.map((o) => [`  ${o.format}`, o.description]) : [],
+      ...this.options.map((o) => [`  ${o.format}`, o.description]),
+      [`  -h, --help`, `Display this message`],
+      [`  -v, --version`, `Display version number`]
+    ]);
+    for (const line of twoColumn(optionHelps)) {
+      println(line);
     }
+    println(``);
+    return output;
+  }
+  option(format, configOrDescription = "", otherConfig = {}) {
+    const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     try {
       const option = new Option(format, config);
       this.options.push(option);
@@ -199,32 +550,64 @@ class Breadc {
     }
     return this;
   }
-  command(format, config = {}) {
+  command(format, configOrDescription = "", otherConfig = {}) {
+    const config = typeof configOrDescription === "object" ? configOrDescription : { ...otherConfig, description: configOrDescription };
     const command = new Command(format, { ...config, logger: this.logger });
+    if (command.default) {
+      if (this.defaultCommand) {
+        this.logger.warn("You can not have two default commands.");
+      }
+      this.defaultCommand = command;
+    }
     this.commands.push(command);
     return command;
   }
   parse(args) {
-    const allowOptions = [this.options, this.commands.map((c) => c.options)].flat();
+    const allowOptions = [
+      ...this.options,
+      ...this.commands.flatMap((c) => c.options)
+    ];
     const alias = allowOptions.reduce((map, o) => {
       if (o.shortcut) {
         map[o.shortcut] = o.name;
       }
       return map;
     }, {});
+    const defaults = allowOptions.reduce((map, o) => {
+      if (o.default) {
+        map[o.name] = o.default;
+      }
+      return map;
+    }, {});
     const argv = minimist(args, {
       string: allowOptions.filter((o) => o.type === "string").map((o) => o.name),
       boolean: allowOptions.filter((o) => o.type === "boolean").map((o) => o.name),
-      alias
+      alias,
+      default: defaults,
+      unknown: (t) => {
+        if (t[0] !== "-")
+          return true;
+        else {
+          if (["--help", "-h", "--version", "-v"].includes(t)) {
+            return true;
+          } else {
+            this.logger.warn(`Find unknown flag "${t}"`);
+            return false;
+          }
+        }
+      }
     });
     for (const shortcut of Object.keys(alias)) {
       delete argv[shortcut];
     }
     for (const command of this.commands) {
-      if (command.shouldRun(argv)) {
-        return command.parseArgs(argv);
+      if (!command.default && command.shouldRun(argv)) {
+        return command.parseArgs(argv, this.options);
       }
     }
+    if (this.defaultCommand) {
+      return this.defaultCommand.parseArgs(argv, this.options);
+    }
     const argumentss = argv["_"];
     const options = argv;
     delete options["_"];
@@ -241,9 +624,17 @@ class Breadc {
     }
   }
 }
+function twoColumn(texts, split = "  ") {
+  const left = padRight(texts.map((t) => t[0]));
+  return left.map((l, idx) => l + split + texts[idx][1]);
+}
+function padRight(texts, fill = " ") {
+  const length = texts.map((t) => t.length).reduce((max, l) => Math.max(max, l), 0);
+  return texts.map((t) => t + fill.repeat(length - t.length));
+}
 
 function breadc(name, option = {}) {
   return new Breadc(name, option);
 }
 
-export { breadc as default };
+export { breadc as default, minimist };