@tellahq/rescript 10.1.0-alpha.1

package/lib/es6/arg.js

@@ -0,0 +1,717 @@
+
+
+import * as Sys from "./sys.js";
+import * as Caml from "./caml.js";
+import * as List from "./list.js";
+import * as $$Array from "./array.js";
+import * as Curry from "./curry.js";
+import * as $$Buffer from "./buffer.js";
+import * as $$String from "./string.js";
+import * as Caml_obj from "./caml_obj.js";
+import * as Caml_array from "./caml_array.js";
+import * as Pervasives from "./pervasives.js";
+import * as Caml_format from "./caml_format.js";
+import * as Caml_string from "./caml_string.js";
+import * as Caml_exceptions from "./caml_exceptions.js";
+import * as Caml_js_exceptions from "./caml_js_exceptions.js";
+
+var Bad = /* @__PURE__ */Caml_exceptions.create("Arg.Bad");
+
+var Help = /* @__PURE__ */Caml_exceptions.create("Arg.Help");
+
+var Stop = /* @__PURE__ */Caml_exceptions.create("Arg.Stop");
+
+function assoc3(x, _l) {
+  while(true) {
+    var l = _l;
+    if (l) {
+      var match = l.hd;
+      if (Caml_obj.equal(match[0], x)) {
+        return match[1];
+      }
+      _l = l.tl;
+      continue ;
+    }
+    throw {
+          RE_EXN_ID: "Not_found",
+          Error: new Error()
+        };
+  };
+}
+
+function split(s) {
+  var i = $$String.index(s, /* '=' */61);
+  var len = s.length;
+  return [
+          $$String.sub(s, 0, i),
+          $$String.sub(s, i + 1 | 0, len - (i + 1 | 0) | 0)
+        ];
+}
+
+function make_symlist(prefix, sep, suffix, l) {
+  if (l) {
+    return List.fold_left((function (x, y) {
+                  return x + (sep + y);
+                }), prefix + l.hd, l.tl) + suffix;
+  } else {
+    return "<none>";
+  }
+}
+
+function help_action(param) {
+  throw {
+        RE_EXN_ID: Stop,
+        _1: {
+          TAG: /* Unknown */0,
+          _0: "-help"
+        },
+        Error: new Error()
+      };
+}
+
+function add_help(speclist) {
+  var add1;
+  try {
+    assoc3("-help", speclist);
+    add1 = /* [] */0;
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Not_found") {
+      add1 = {
+        hd: [
+          "-help",
+          {
+            TAG: /* Unit */0,
+            _0: help_action
+          },
+          " Display this list of options"
+        ],
+        tl: /* [] */0
+      };
+    } else {
+      throw exn;
+    }
+  }
+  var add2;
+  try {
+    assoc3("--help", speclist);
+    add2 = /* [] */0;
+  }
+  catch (raw_exn$1){
+    var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+    if (exn$1.RE_EXN_ID === "Not_found") {
+      add2 = {
+        hd: [
+          "--help",
+          {
+            TAG: /* Unit */0,
+            _0: help_action
+          },
+          " Display this list of options"
+        ],
+        tl: /* [] */0
+      };
+    } else {
+      throw exn$1;
+    }
+  }
+  return Pervasives.$at(speclist, Pervasives.$at(add1, add2));
+}
+
+function usage_b(buf, speclist, errmsg) {
+  $$Buffer.add_string(buf, "" + errmsg + "\n");
+  List.iter((function (param) {
+          var doc = param[2];
+          if (doc.length === 0) {
+            return ;
+          }
+          var spec = param[1];
+          var key = param[0];
+          if (spec.TAG !== /* Symbol */11) {
+            return $$Buffer.add_string(buf, "  " + key + " " + doc + "\n");
+          }
+          var sym = make_symlist("{", "|", "}", spec._0);
+          return $$Buffer.add_string(buf, "  " + key + " " + sym + doc + "\n");
+        }), add_help(speclist));
+}
+
+function usage_string(speclist, errmsg) {
+  var b = $$Buffer.create(200);
+  usage_b(b, speclist, errmsg);
+  return $$Buffer.contents(b);
+}
+
+function usage(speclist, errmsg) {
+  console.log(usage_string(speclist, errmsg));
+}
+
+var current = {
+  contents: 0
+};
+
+function bool_of_string_opt(x) {
+  try {
+    return Pervasives.bool_of_string(x);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Invalid_argument") {
+      return ;
+    }
+    throw exn;
+  }
+}
+
+function int_of_string_opt(x) {
+  try {
+    return Caml_format.int_of_string(x);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Failure") {
+      return ;
+    }
+    throw exn;
+  }
+}
+
+function float_of_string_opt(x) {
+  try {
+    return Caml_format.float_of_string(x);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Failure") {
+      return ;
+    }
+    throw exn;
+  }
+}
+
+function parse_and_expand_argv_dynamic_aux(allow_expand, current, argv, speclist, anonfun, errmsg) {
+  var initpos = current.contents;
+  var convert_error = function (error) {
+    var b = $$Buffer.create(200);
+    var progname = initpos < argv.contents.length ? Caml_array.get(argv.contents, initpos) : "(?)";
+    switch (error.TAG | 0) {
+      case /* Unknown */0 :
+          var s = error._0;
+          switch (s) {
+            case "--help" :
+            case "-help" :
+                break;
+            default:
+              $$Buffer.add_string(b, "" + progname + ": unknown option '" + s + "'.\n");
+          }
+          break;
+      case /* Wrong */1 :
+          $$Buffer.add_string(b, "" + progname + ": wrong argument '" + error._1 + "'; option '" + error._0 + "' expects " + error._2 + ".\n");
+          break;
+      case /* Missing */2 :
+          $$Buffer.add_string(b, "" + progname + ": option '" + error._0 + "' needs an argument.\n");
+          break;
+      case /* Message */3 :
+          $$Buffer.add_string(b, "" + progname + ": " + error._0 + ".\n");
+          break;
+      
+    }
+    usage_b(b, speclist.contents, errmsg);
+    if (Caml_obj.equal(error, {
+            TAG: /* Unknown */0,
+            _0: "-help"
+          }) || Caml_obj.equal(error, {
+            TAG: /* Unknown */0,
+            _0: "--help"
+          })) {
+      return {
+              RE_EXN_ID: Help,
+              _1: $$Buffer.contents(b)
+            };
+    } else {
+      return {
+              RE_EXN_ID: Bad,
+              _1: $$Buffer.contents(b)
+            };
+    }
+  };
+  current.contents = current.contents + 1 | 0;
+  while(current.contents < argv.contents.length) {
+    try {
+      var s = Caml_array.get(argv.contents, current.contents);
+      if (s.length >= 1 && Caml_string.get(s, 0) === /* '-' */45) {
+        var match;
+        try {
+          match = [
+            assoc3(s, speclist.contents),
+            undefined
+          ];
+        }
+        catch (raw_exn){
+          var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+          if (exn.RE_EXN_ID === "Not_found") {
+            try {
+              var match$1 = split(s);
+              match = [
+                assoc3(match$1[0], speclist.contents),
+                match$1[1]
+              ];
+            }
+            catch (raw_exn$1){
+              var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+              if (exn$1.RE_EXN_ID === "Not_found") {
+                throw {
+                      RE_EXN_ID: Stop,
+                      _1: {
+                        TAG: /* Unknown */0,
+                        _0: s
+                      },
+                      Error: new Error()
+                    };
+              }
+              throw exn$1;
+            }
+          } else {
+            throw exn;
+          }
+        }
+        var follow = match[1];
+        var no_arg = (function(s,follow){
+        return function no_arg(param) {
+          if (follow === undefined) {
+            return ;
+          }
+          throw {
+                RE_EXN_ID: Stop,
+                _1: {
+                  TAG: /* Wrong */1,
+                  _0: s,
+                  _1: follow,
+                  _2: "no argument"
+                },
+                Error: new Error()
+              };
+        }
+        }(s,follow));
+        var get_arg = (function(s,follow){
+        return function get_arg(param) {
+          if (follow !== undefined) {
+            return follow;
+          }
+          if ((current.contents + 1 | 0) < argv.contents.length) {
+            return Caml_array.get(argv.contents, current.contents + 1 | 0);
+          }
+          throw {
+                RE_EXN_ID: Stop,
+                _1: {
+                  TAG: /* Missing */2,
+                  _0: s
+                },
+                Error: new Error()
+              };
+        }
+        }(s,follow));
+        var consume_arg = (function(follow){
+        return function consume_arg(param) {
+          if (follow !== undefined) {
+            return ;
+          } else {
+            current.contents = current.contents + 1 | 0;
+            return ;
+          }
+        }
+        }(follow));
+        var treat_action = (function(s){
+        return function treat_action(f) {
+          switch (f.TAG | 0) {
+            case /* Unit */0 :
+                return Curry._1(f._0, undefined);
+            case /* Bool */1 :
+                var arg = get_arg(undefined);
+                var s$1 = bool_of_string_opt(arg);
+                if (s$1 !== undefined) {
+                  Curry._1(f._0, s$1);
+                } else {
+                  throw {
+                        RE_EXN_ID: Stop,
+                        _1: {
+                          TAG: /* Wrong */1,
+                          _0: s,
+                          _1: arg,
+                          _2: "a boolean"
+                        },
+                        Error: new Error()
+                      };
+                }
+                return consume_arg(undefined);
+            case /* Set */2 :
+                no_arg(undefined);
+                f._0.contents = true;
+                return ;
+            case /* Clear */3 :
+                no_arg(undefined);
+                f._0.contents = false;
+                return ;
+            case /* String */4 :
+                var arg$1 = get_arg(undefined);
+                Curry._1(f._0, arg$1);
+                return consume_arg(undefined);
+            case /* Set_string */5 :
+                f._0.contents = get_arg(undefined);
+                return consume_arg(undefined);
+            case /* Int */6 :
+                var arg$2 = get_arg(undefined);
+                var x = int_of_string_opt(arg$2);
+                if (x !== undefined) {
+                  Curry._1(f._0, x);
+                } else {
+                  throw {
+                        RE_EXN_ID: Stop,
+                        _1: {
+                          TAG: /* Wrong */1,
+                          _0: s,
+                          _1: arg$2,
+                          _2: "an integer"
+                        },
+                        Error: new Error()
+                      };
+                }
+                return consume_arg(undefined);
+            case /* Set_int */7 :
+                var arg$3 = get_arg(undefined);
+                var x$1 = int_of_string_opt(arg$3);
+                if (x$1 !== undefined) {
+                  f._0.contents = x$1;
+                } else {
+                  throw {
+                        RE_EXN_ID: Stop,
+                        _1: {
+                          TAG: /* Wrong */1,
+                          _0: s,
+                          _1: arg$3,
+                          _2: "an integer"
+                        },
+                        Error: new Error()
+                      };
+                }
+                return consume_arg(undefined);
+            case /* Float */8 :
+                var arg$4 = get_arg(undefined);
+                var x$2 = float_of_string_opt(arg$4);
+                if (x$2 !== undefined) {
+                  Curry._1(f._0, x$2);
+                } else {
+                  throw {
+                        RE_EXN_ID: Stop,
+                        _1: {
+                          TAG: /* Wrong */1,
+                          _0: s,
+                          _1: arg$4,
+                          _2: "a float"
+                        },
+                        Error: new Error()
+                      };
+                }
+                return consume_arg(undefined);
+            case /* Set_float */9 :
+                var arg$5 = get_arg(undefined);
+                var x$3 = float_of_string_opt(arg$5);
+                if (x$3 !== undefined) {
+                  f._0.contents = x$3;
+                } else {
+                  throw {
+                        RE_EXN_ID: Stop,
+                        _1: {
+                          TAG: /* Wrong */1,
+                          _0: s,
+                          _1: arg$5,
+                          _2: "a float"
+                        },
+                        Error: new Error()
+                      };
+                }
+                return consume_arg(undefined);
+            case /* Tuple */10 :
+                return List.iter(treat_action, f._0);
+            case /* Symbol */11 :
+                var symb = f._0;
+                var arg$6 = get_arg(undefined);
+                if (List.mem(arg$6, symb)) {
+                  Curry._1(f._1, arg$6);
+                  return consume_arg(undefined);
+                }
+                throw {
+                      RE_EXN_ID: Stop,
+                      _1: {
+                        TAG: /* Wrong */1,
+                        _0: s,
+                        _1: arg$6,
+                        _2: "one of: " + make_symlist("", " ", "", symb)
+                      },
+                      Error: new Error()
+                    };
+            case /* Rest */12 :
+                var f$1 = f._0;
+                while(current.contents < (argv.contents.length - 1 | 0)) {
+                  Curry._1(f$1, Caml_array.get(argv.contents, current.contents + 1 | 0));
+                  consume_arg(undefined);
+                };
+                return ;
+            case /* Expand */13 :
+                if (!allow_expand) {
+                  throw {
+                        RE_EXN_ID: "Invalid_argument",
+                        _1: "Arg.Expand is is only allowed with Arg.parse_and_expand_argv_dynamic",
+                        Error: new Error()
+                      };
+                }
+                var arg$7 = get_arg(undefined);
+                var newarg = Curry._1(f._0, arg$7);
+                consume_arg(undefined);
+                var before = $$Array.sub(argv.contents, 0, current.contents + 1 | 0);
+                var after = $$Array.sub(argv.contents, current.contents + 1 | 0, (argv.contents.length - current.contents | 0) - 1 | 0);
+                argv.contents = Caml_array.concat({
+                      hd: before,
+                      tl: {
+                        hd: newarg,
+                        tl: {
+                          hd: after,
+                          tl: /* [] */0
+                        }
+                      }
+                    });
+                return ;
+            
+          }
+        }
+        }(s));
+        treat_action(match[0]);
+      } else {
+        Curry._1(anonfun, s);
+      }
+    }
+    catch (raw_m){
+      var m = Caml_js_exceptions.internalToOCamlException(raw_m);
+      if (m.RE_EXN_ID === Bad) {
+        throw convert_error({
+                  TAG: /* Message */3,
+                  _0: m._1
+                });
+      }
+      if (m.RE_EXN_ID === Stop) {
+        throw convert_error(m._1);
+      }
+      throw m;
+    }
+    current.contents = current.contents + 1 | 0;
+  };
+}
+
+function parse_and_expand_argv_dynamic(current, argv, speclist, anonfun, errmsg) {
+  parse_and_expand_argv_dynamic_aux(true, current, argv, speclist, anonfun, errmsg);
+}
+
+function parse_argv_dynamic(currentOpt, argv, speclist, anonfun, errmsg) {
+  var current$1 = currentOpt !== undefined ? currentOpt : current;
+  parse_and_expand_argv_dynamic_aux(false, current$1, {
+        contents: argv
+      }, speclist, anonfun, errmsg);
+}
+
+function parse_argv(currentOpt, argv, speclist, anonfun, errmsg) {
+  var current$1 = currentOpt !== undefined ? currentOpt : current;
+  parse_argv_dynamic(current$1, argv, {
+        contents: speclist
+      }, anonfun, errmsg);
+}
+
+function parse(l, f, msg) {
+  try {
+    return parse_argv(undefined, Sys.argv, l, f, msg);
+  }
+  catch (raw_msg){
+    var msg$1 = Caml_js_exceptions.internalToOCamlException(raw_msg);
+    if (msg$1.RE_EXN_ID === Bad) {
+      console.log(msg$1._1);
+      return Pervasives.exit(2);
+    }
+    if (msg$1.RE_EXN_ID === Help) {
+      console.log(msg$1._1);
+      return Pervasives.exit(0);
+    }
+    throw msg$1;
+  }
+}
+
+function parse_dynamic(l, f, msg) {
+  try {
+    return parse_argv_dynamic(undefined, Sys.argv, l, f, msg);
+  }
+  catch (raw_msg){
+    var msg$1 = Caml_js_exceptions.internalToOCamlException(raw_msg);
+    if (msg$1.RE_EXN_ID === Bad) {
+      console.log(msg$1._1);
+      return Pervasives.exit(2);
+    }
+    if (msg$1.RE_EXN_ID === Help) {
+      console.log(msg$1._1);
+      return Pervasives.exit(0);
+    }
+    throw msg$1;
+  }
+}
+
+function parse_expand(l, f, msg) {
+  try {
+    var argv = {
+      contents: Sys.argv
+    };
+    var spec = {
+      contents: l
+    };
+    var current$1 = {
+      contents: current.contents
+    };
+    return parse_and_expand_argv_dynamic(current$1, argv, spec, f, msg);
+  }
+  catch (raw_msg){
+    var msg$1 = Caml_js_exceptions.internalToOCamlException(raw_msg);
+    if (msg$1.RE_EXN_ID === Bad) {
+      console.log(msg$1._1);
+      return Pervasives.exit(2);
+    }
+    if (msg$1.RE_EXN_ID === Help) {
+      console.log(msg$1._1);
+      return Pervasives.exit(0);
+    }
+    throw msg$1;
+  }
+}
+
+function second_word(s) {
+  var len = s.length;
+  var loop = function (_n) {
+    while(true) {
+      var n = _n;
+      if (n >= len) {
+        return len;
+      }
+      if (Caml_string.get(s, n) !== /* ' ' */32) {
+        return n;
+      }
+      _n = n + 1 | 0;
+      continue ;
+    };
+  };
+  var n;
+  try {
+    n = $$String.index(s, /* '\t' */9);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    if (exn.RE_EXN_ID === "Not_found") {
+      var exit = 0;
+      var n$1;
+      try {
+        n$1 = $$String.index(s, /* ' ' */32);
+        exit = 2;
+      }
+      catch (raw_exn$1){
+        var exn$1 = Caml_js_exceptions.internalToOCamlException(raw_exn$1);
+        if (exn$1.RE_EXN_ID === "Not_found") {
+          return len;
+        }
+        throw exn$1;
+      }
+      if (exit === 2) {
+        return loop(n$1 + 1 | 0);
+      }
+      
+    } else {
+      throw exn;
+    }
+  }
+  return loop(n + 1 | 0);
+}
+
+function max_arg_len(cur, param) {
+  var kwd = param[0];
+  if (param[1].TAG === /* Symbol */11) {
+    return Caml.int_max(cur, kwd.length);
+  } else {
+    return Caml.int_max(cur, kwd.length + second_word(param[2]) | 0);
+  }
+}
+
+function replace_leading_tab(s) {
+  var seen = {
+    contents: false
+  };
+  return $$String.map((function (c) {
+                if (c !== 9 || seen.contents) {
+                  return c;
+                } else {
+                  seen.contents = true;
+                  return /* ' ' */32;
+                }
+              }), s);
+}
+
+function align(limitOpt, speclist) {
+  var limit = limitOpt !== undefined ? limitOpt : Pervasives.max_int;
+  var completed = add_help(speclist);
+  var len = List.fold_left(max_arg_len, 0, completed);
+  var len$1 = len < limit ? len : limit;
+  return List.map((function (param) {
+                var spec = param[1];
+                var kwd = param[0];
+                if (param[2] === "") {
+                  return param;
+                }
+                if (spec.TAG === /* Symbol */11) {
+                  var msg = param[2];
+                  var cutcol = second_word(msg);
+                  var spaces = " ".repeat(Caml.int_max(0, len$1 - cutcol | 0) + 3 | 0);
+                  return [
+                          kwd,
+                          spec,
+                          "\n" + (spaces + replace_leading_tab(msg))
+                        ];
+                }
+                var msg$1 = param[2];
+                var cutcol$1 = second_word(msg$1);
+                var kwd_len = kwd.length;
+                var diff = (len$1 - kwd_len | 0) - cutcol$1 | 0;
+                if (diff <= 0) {
+                  return [
+                          kwd,
+                          spec,
+                          replace_leading_tab(msg$1)
+                        ];
+                }
+                var spaces$1 = " ".repeat(diff);
+                var prefix = $$String.sub(replace_leading_tab(msg$1), 0, cutcol$1);
+                var suffix = $$String.sub(msg$1, cutcol$1, msg$1.length - cutcol$1 | 0);
+                return [
+                        kwd,
+                        spec,
+                        prefix + (spaces$1 + suffix)
+                      ];
+              }), completed);
+}
+
+export {
+  parse ,
+  parse_dynamic ,
+  parse_argv ,
+  parse_argv_dynamic ,
+  parse_and_expand_argv_dynamic ,
+  parse_expand ,
+  Help ,
+  Bad ,
+  usage ,
+  usage_string ,
+  align ,
+  current ,
+}
+/* No side effect */