@reventlessdev/reventless-spec 3.0.0-alpha.143 → 3.0.0-alpha.144

package/src/generator/GraftTrait.res

@@ -46,30 +46,6 @@ let usage = `Usage: graft-trait <trait-package> --into <srcDir> --tests <testsDi
 
 // ── Arguments ────────────────────────────────────────────────────────────────
 
-/** `--key value` pairs, in order, with the leading positional taken off first.
-    A flag with no value (`--dry-run`) reads as `true`, so the config schema can
-    take it as a boolean without the CLI knowing which keys are flags. */
-let parseFlags = (args: array<string>): dict<JSON.t> => {
-  let out = Dict.make()
-  let rec go = i =>
-    switch args->Array.get(i) {
-    | None => ()
-    | Some(arg) if arg->String.startsWith("--") =>
-      let key = arg->String.slice(~start=2, ~end=arg->String.length)
-      switch args->Array.get(i + 1) {
-      | Some(value) if !(value->String.startsWith("--")) =>
-        out->Dict.set(key, JSON.Encode.string(value))
-        go(i + 2)
-      | _ =>
-        out->Dict.set(key, JSON.Encode.bool(true))
-        go(i + 1)
-      }
-    | Some(_) => go(i + 1)
-    }
-  go(0)
-  out
-}
-
 /** A comma-separated value becomes an array. Applied only to keys the trait's
     schema declares as arrays, so a name that happens to contain a comma is not
     split behind the author's back. */
@@ -106,134 +82,157 @@ let arrayFieldNames = (schema: S.t<unknown>): array<string> =>
 
 // ── Entry point ──────────────────────────────────────────────────────────────
 
-let main = async () => {
-  let argv = NodeProcess.argv->Array.slice(~start=2, ~end=NodeProcess.argv->Array.length)
-  switch argv->Array.get(0) {
-  | None | Some("") | Some("--help") | Some("-h") => {
-      Console.log(usage)
-      NodeProcess.exit(argv->Array.length == 0 ? 1 : 0)
+/** The trait, where its graft goes, and every other `--key value` as a field of
+    the trait's config — a string, or `true` for a key given no value. */
+type args = {
+  traitPackage: string,
+  into: string,
+  tests: string,
+  dryRun: bool,
+  fields: dict<JSON.t>,
+}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  CliArgs.parse(~strings=["into", "tests"], ~bools=["dry-run"], ~pairs=true, argv)
+  ->Result.flatMap(a => a->CliArgs.atMost(1))
+  ->Result.flatMap(a =>
+    switch (
+      a->CliArgs.positionals->Array.get(0),
+      a->CliArgs.string("into"),
+      a->CliArgs.string("tests"),
+    ) {
+    | (None | Some(""), _, _) => Error("<trait-package> is required.")
+    | (Some(traitPackage), Some(into), Some(tests)) =>
+      // A key given no value reads as `true`, so the config schema can take it
+      // as a boolean without the tool knowing which keys are flags.
+      let fields = Dict.make()
+      a
+      ->CliArgs.pairs
+      ->Array.forEach(((key, value)) =>
+        fields->Dict.set(
+          key,
+          switch value {
+          | Text(text) => JSON.Encode.string(text)
+          | Present => JSON.Encode.bool(true)
+          },
+        )
+      )
+      Ok({traitPackage, into, tests, dryRun: a->CliArgs.bool("dry-run"), fields})
+    | (Some(_), _, _) => Error("--into and --tests are both required.")
+    }
+  )
+
+let cli: CliArgs.cli<args> = {bin: "graft-trait", usage, parse: parseArgs}
+
+let main = () =>
+  CliArgs.run(cli, async ({traitPackage, into, tests, dryRun, fields}) => {
+    // Resolved by name, from the consumer's own `node_modules`. A trait
+    // that ships no scaffold fails here, saying so, rather than half-way
+    // through writing files.
+    // `@scope/trait-attachments` → `Attachments_Scaffold`;
+    // `@scope/trait-address-geocoding` → `AddressGeocoding_Scaffold`.
+    let scaffoldModule =
+      traitPackage
+      ->String.split("/")
+      ->Array.last
+      ->Option.getOr("")
+      ->String.replace("trait-", "")
+      ->String.split("-")
+      ->Array.map(part =>
+        part->String.charAt(0)->String.toUpperCase ++
+          part->String.slice(~start=1, ~end=part->String.length)
+      )
+      ->Array.join("") ++ "_Scaffold"
+    let specifier = `${traitPackage}/src/${scaffoldModule}.res.mjs`
+    // Resolved from the **caller's** directory, not this file's. The trait
+    // is a dependency of the plugin being grafted, and deliberately not one
+    // of this package — a bare `import()` here would look in
+    // `reventless-spec`'s own tree and never find it. Same reason
+    // `HostShellDist` reaches for the host shell this way.
+    let modulePath = try NodeModule.createRequire(
+      NodeProcess.cwd() ++ "/index.js",
+    )->NodeModule.requireResolve(specifier) catch {
+    | _ => specifier
+    }
+    let scaffold: scaffoldExports = try await dynImport(
+      NodeUrl.pathToFileURL(modulePath)["href"],
+    ) catch {
+    | _ =>
+      fail(
+        `${traitPackage} ships no scaffold (looked for ${specifier}).\n` ++
+        `  Not every trait has one — a trait whose graft is all patches has nothing to write.\n` ++ `  Write the graft by hand instead; its README says what the host must declare.`,
+      )
+      %raw(`undefined`)
     }
-  | Some(traitPackage) => {
-      let flags = parseFlags(argv->Array.slice(~start=1, ~end=argv->Array.length))
-      let stringFlag = key => flags->Dict.get(key)->Option.flatMap(JSON.Decode.string)
-      let into = stringFlag("into")
-      let tests = stringFlag("tests")
-      let dryRun = flags->Dict.get("dry-run")->Option.isSome
-
-      switch (into, tests) {
-      | (None, _) | (_, None) => fail("--into and --tests are both required.\n\n" ++ usage)
-      | (Some(into), Some(tests)) => {
-          // Resolved by name, from the consumer's own `node_modules`. A trait
-          // that ships no scaffold fails here, saying so, rather than half-way
-          // through writing files.
-          // `@scope/trait-attachments` → `Attachments_Scaffold`;
-          // `@scope/trait-address-geocoding` → `AddressGeocoding_Scaffold`.
-          let scaffoldModule =
-            traitPackage
-            ->String.split("/")
-            ->Array.last
-            ->Option.getOr("")
-            ->String.replace("trait-", "")
-            ->String.split("-")
-            ->Array.map(part =>
-              part->String.charAt(0)->String.toUpperCase ++
-                part->String.slice(~start=1, ~end=part->String.length)
-            )
-            ->Array.join("") ++ "_Scaffold"
-          let specifier = `${traitPackage}/src/${scaffoldModule}.res.mjs`
-          // Resolved from the **caller's** directory, not this file's. The trait
-          // is a dependency of the plugin being grafted, and deliberately not one
-          // of this package — a bare `import()` here would look in
-          // `reventless-spec`'s own tree and never find it. Same reason
-          // `HostShellDist` reaches for the host shell this way.
-          let modulePath = try NodeModule.createRequire(
-            NodeProcess.cwd() ++ "/index.js",
-          )->NodeModule.requireResolve(specifier) catch {
-          | _ => specifier
-          }
-          let scaffold: scaffoldExports = try await dynImport(
-            NodeUrl.pathToFileURL(modulePath)["href"],
-          ) catch {
-          | _ =>
-            fail(
-              `${traitPackage} ships no scaffold (looked for ${specifier}).\n` ++
-              `  Not every trait has one — a trait whose graft is all patches has nothing to write.\n` ++ `  Write the graft by hand instead; its README says what the host must declare.`,
-            )
-            %raw(`undefined`)
-          }
 
-          // The trait validates its own config, so the CLI never learns a
-          // trait's vocabulary — and a misspelled key is named here.
-          let listFields = arrayFieldNames(scaffold.configSchema)
-          let raw = Dict.make()
-          flags
-          ->Dict.toArray
-          ->Array.forEach(((key, value)) =>
-            switch (listFields->Array.includes(key), value->JSON.Decode.string) {
-            | (true, Some(text)) => raw->Dict.set(key, splitList(text))
-            | _ => raw->Dict.set(key, value)
-            }
-          )
-          ["into", "tests", "dry-run"]->Array.forEach(k => raw->Dict.delete(k))
-
-          let config = try raw
-          ->JSON.Encode.object
-          ->Util_Sury.fromJson(scaffold.configSchema) catch {
-          | exn => {
-              fail(
-                `${traitPackage} refused this config: ${Util_Sury.exnMessage(
-                    exn,
-                  )}\n` ++ `  Every --key is a field of the trait's own config; it decides what it needs.`,
-              )
-              %raw(`undefined`)
-            }
-          }
+    // The trait validates its own config, so the CLI never learns a
+    // trait's vocabulary — and a misspelled key is named here.
+    let listFields = arrayFieldNames(scaffold.configSchema)
+    let raw = Dict.make()
+    fields
+    ->Dict.toArray
+    ->Array.forEach(((key, value)) =>
+      switch (listFields->Array.includes(key), value->JSON.Decode.string) {
+      | (true, Some(text)) => raw->Dict.set(key, splitList(text))
+      | _ => raw->Dict.set(key, value)
+      }
+    )
 
-          let {files, patches} = scaffold.emit(~config, ~into, ~tests)
-
-          files->Array.forEach(({path, contents}) =>
-            if dryRun {
-              Console.log(
-                `Would write: ${path} (${contents
-                  ->String.split("\n")
-                  ->Array.length
-                  ->Int.toString} lines)`,
-              )
-            } else if NodeFs.existsSync(path) {
-              // Never overwrite. From the moment a graft lands it is the host's
-              // source, edited with the policy the trait deliberately does not
-              // write — silently replacing it would delete exactly the part no
-              // generator can reproduce.
-              Console.log(`Skipped (exists): ${path}`)
-            } else {
-              NodeFs.mkdirSync(NodePath.dirname(path), {recursive: true})
-              NodeFs.writeFileSync(path, contents)
-              Console.log(`Wrote: ${path}`)
-            }
-          )
-
-          if patches->Array.length > 0 {
-            Console.log("")
-            Console.log(
-              "── Paste these; they go into files you already own ──────────────",
-            )
-            patches->Array.forEach(({into, at, contents}) => {
-              Console.log("")
-              Console.log(`# ${into} — ${at}`)
-              Console.log(contents)
-            })
-            Console.log("")
-            Console.log(
-              "Printed rather than written: placing an arm in an existing ordered `switch`\n" ++
-              "is an AST operation, and a text splice into the wrong arm is a bug the\n" ++ "compiler cannot see.",
-            )
-          }
+    let config = try raw
+    ->JSON.Encode.object
+    ->Util_Sury.fromJson(scaffold.configSchema) catch {
+    | exn => {
+        fail(
+          `${traitPackage} refused this config: ${Util_Sury.exnMessage(
+              exn,
+            )}\n` ++ `  Every --key is a field of the trait's own config; it decides what it needs.`,
+        )
+        %raw(`undefined`)
+      }
+    }
+
+    let {files, patches} = scaffold.emit(~config, ~into, ~tests)
 
-          NodeProcess.exit(0)
-        }
+    files->Array.forEach(({path, contents}) =>
+      if dryRun {
+        Console.log(
+          `Would write: ${path} (${contents
+            ->String.split("\n")
+            ->Array.length
+            ->Int.toString} lines)`,
+        )
+      } else if NodeFs.existsSync(path) {
+        // Never overwrite. From the moment a graft lands it is the host's
+        // source, edited with the policy the trait deliberately does not
+        // write — silently replacing it would delete exactly the part no
+        // generator can reproduce.
+        Console.log(`Skipped (exists): ${path}`)
+      } else {
+        NodeFs.mkdirSync(NodePath.dirname(path), {recursive: true})
+        NodeFs.writeFileSync(path, contents)
+        Console.log(`Wrote: ${path}`)
       }
+    )
+
+    if patches->Array.length > 0 {
+      Console.log("")
+      Console.log(
+        "── Paste these; they go into files you already own ──────────────",
+      )
+      patches->Array.forEach(({into, at, contents}) => {
+        Console.log("")
+        Console.log(`# ${into} — ${at}`)
+        Console.log(contents)
+      })
+      Console.log("")
+      Console.log(
+        "Printed rather than written: placing an arm in an existing ordered `switch`\n" ++
+        "is an AST operation, and a text splice into the wrong arm is a bug the\n" ++ "compiler cannot see.",
+      )
     }
-  }
-}
 
-await main()
+    NodeProcess.exit(0)
+  })
+
+// No top-level call: `../../run-graft-trait.mjs` invokes [main], so a test can
+// import this module.

package/src/generator/GraftTrait.res.mjs

@@ -3,11 +3,12 @@
 import * as Nodefs from "node:fs";
 import * as Nodeurl from "node:url";
 import * as Nodepath from "node:path";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Nodemodule from "node:module";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as CliArgs$Reventless from "../CliArgs.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Util_Sury$Reventless from "../util/Util_Sury.res.mjs";
 
@@ -26,35 +27,6 @@ let usage = `Usage: graft-trait <trait-package> --into <srcDir> --tests <testsDi
   Every other --key value is a field of the trait's config. The trait validates
   them, so run it once to be told what it wants.`;
 
-function parseFlags(args) {
-  let out = {};
-  let go = _i => {
-    while (true) {
-      let i = _i;
-      let arg = args[i];
-      if (arg === undefined) {
-        return;
-      }
-      if (arg.startsWith("--")) {
-        let key = arg.slice(2, arg.length);
-        let value = args[i + 1 | 0];
-        if (value !== undefined && !value.startsWith("--")) {
-          out[key] = value;
-          _i = i + 2 | 0;
-          continue;
-        }
-        out[key] = true;
-        _i = i + 1 | 0;
-        continue;
-      }
-      _i = i + 1 | 0;
-      continue;
-    };
-  };
-  go(0);
-  return out;
-}
-
 function splitList(value) {
   return value.split(",").map(part => part.trim()).filter(part => part !== "").map(prim => prim);
 }
@@ -82,112 +54,143 @@ function arrayFieldNames(schema) {
   }
 }
 
-async function main() {
-  let argv = process.argv.slice(2, process.argv.length);
-  let traitPackage = argv[0];
-  if (traitPackage !== undefined) {
-    switch (traitPackage) {
-      case "" :
-      case "--help" :
-      case "-h" :
-        break;
-      default:
-        let flags = parseFlags(argv.slice(1, argv.length));
-        let stringFlag = key => Stdlib_Option.flatMap(flags[key], Stdlib_JSON.Decode.string);
-        let into = stringFlag("into");
-        let tests = stringFlag("tests");
-        let dryRun = Stdlib_Option.isSome(flags["dry-run"]);
-        if (into === undefined) {
-          return fail("--into and --tests are both required.\n\n" + usage);
-        }
-        if (tests === undefined) {
-          return fail("--into and --tests are both required.\n\n" + usage);
-        }
-        let scaffoldModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Scaffold";
-        let specifier = traitPackage + `/src/` + scaffoldModule + `.res.mjs`;
-        let modulePath;
-        try {
-          modulePath = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
-        } catch (exn) {
-          modulePath = specifier;
-        }
-        let scaffold;
-        try {
-          scaffold = await import(Nodeurl.pathToFileURL(modulePath).href);
-        } catch (exn$1) {
-          fail(traitPackage + ` ships no scaffold (looked for ` + specifier + `).\n  Not every trait has one — a trait whose graft is all patches has nothing to write.\n  Write the graft by hand instead; its README says what the host must declare.`);
-          scaffold = undefined;
-        }
-        let listFields = arrayFieldNames(scaffold.configSchema);
-        let raw = {};
-        Object.entries(flags).forEach(param => {
-          let value = param[1];
-          let key = param[0];
-          let match = listFields.includes(key);
-          let match$1 = Stdlib_JSON.Decode.string(value);
-          if (match && match$1 !== undefined) {
-            raw[key] = splitList(match$1);
-          } else {
-            raw[key] = value;
-          }
-        });
-        [
-          "into",
-          "tests",
-          "dry-run"
-        ].forEach(k => Stdlib_Dict.$$delete(raw, k));
-        let config;
-        try {
-          config = Util_Sury$Reventless.fromJson(raw, scaffold.configSchema);
-        } catch (raw_exn) {
-          let exn$2 = Primitive_exceptions.internalToException(raw_exn);
-          fail(traitPackage + ` refused this config: ` + Util_Sury$Reventless.exnMessage(exn$2, undefined) + `\n  Every --key is a field of the trait's own config; it decides what it needs.`);
-          config = undefined;
-        }
-        let match = scaffold.emit(config, into, tests);
-        let patches = match.patches;
-        match.files.forEach(param => {
-          let contents = param.contents;
-          let path = param.path;
-          if (dryRun) {
-            console.log(`Would write: ` + path + ` (` + contents.split("\n").length.toString() + ` lines)`);
-          } else if (Nodefs.existsSync(path)) {
-            console.log(`Skipped (exists): ` + path);
-          } else {
-            Nodefs.mkdirSync(Nodepath.dirname(path), {
-              recursive: true
-            });
-            Nodefs.writeFileSync(path, contents, "utf8");
-            console.log(`Wrote: ` + path);
-          }
-        });
-        if (patches.length !== 0) {
-          console.log("");
-          console.log("── Paste these; they go into files you already own ──────────────");
-          patches.forEach(param => {
-            console.log("");
-            console.log(`# ` + param.into + ` — ` + param.at);
-            console.log(param.contents);
-          });
-          console.log("");
-          console.log("Printed rather than written: placing an arm in an existing ordered `switch`\nis an AST operation, and a text splice into the wrong arm is a bug the\ncompiler cannot see.");
-        }
-        process.exit(0);
-        return;
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse([
+    "into",
+    "tests"
+  ], ["dry-run"], undefined, true, argv), a => CliArgs$Reventless.atMost(a, 1)), a => {
+    let match = CliArgs$Reventless.positionals(a)[0];
+    let match$1 = CliArgs$Reventless.string(a, "into");
+    let match$2 = CliArgs$Reventless.string(a, "tests");
+    if (match === undefined) {
+      return {
+        TAG: "Error",
+        _0: "<trait-package> is required."
+      };
     }
-  }
-  console.log(usage);
-  process.exit(argv.length === 0 ? 1 : 0);
+    if (match === "") {
+      return {
+        TAG: "Error",
+        _0: "<trait-package> is required."
+      };
+    }
+    if (match$1 === undefined) {
+      return {
+        TAG: "Error",
+        _0: "--into and --tests are both required."
+      };
+    }
+    if (match$2 === undefined) {
+      return {
+        TAG: "Error",
+        _0: "--into and --tests are both required."
+      };
+    }
+    let fields = {};
+    CliArgs$Reventless.pairs(a).forEach(param => {
+      let value = param[1];
+      let tmp;
+      tmp = typeof value !== "object" ? true : value._0;
+      fields[param[0]] = tmp;
+    });
+    return {
+      TAG: "Ok",
+      _0: {
+        traitPackage: match,
+        into: match$1,
+        tests: match$2,
+        dryRun: CliArgs$Reventless.bool(a, "dry-run"),
+        fields: fields
+      }
+    };
+  });
 }
 
-await main();
+let cli = {
+  bin: "graft-trait",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let dryRun = param.dryRun;
+    let traitPackage = param.traitPackage;
+    let scaffoldModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Scaffold";
+    let specifier = traitPackage + `/src/` + scaffoldModule + `.res.mjs`;
+    let modulePath;
+    try {
+      modulePath = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
+    } catch (exn) {
+      modulePath = specifier;
+    }
+    let scaffold;
+    try {
+      scaffold = await import(Nodeurl.pathToFileURL(modulePath).href);
+    } catch (exn$1) {
+      fail(traitPackage + ` ships no scaffold (looked for ` + specifier + `).\n  Not every trait has one — a trait whose graft is all patches has nothing to write.\n  Write the graft by hand instead; its README says what the host must declare.`);
+      scaffold = undefined;
+    }
+    let listFields = arrayFieldNames(scaffold.configSchema);
+    let raw = {};
+    Object.entries(param.fields).forEach(param => {
+      let value = param[1];
+      let key = param[0];
+      let match = listFields.includes(key);
+      let match$1 = Stdlib_JSON.Decode.string(value);
+      if (match && match$1 !== undefined) {
+        raw[key] = splitList(match$1);
+      } else {
+        raw[key] = value;
+      }
+    });
+    let config;
+    try {
+      config = Util_Sury$Reventless.fromJson(raw, scaffold.configSchema);
+    } catch (raw_exn) {
+      let exn$2 = Primitive_exceptions.internalToException(raw_exn);
+      fail(traitPackage + ` refused this config: ` + Util_Sury$Reventless.exnMessage(exn$2, undefined) + `\n  Every --key is a field of the trait's own config; it decides what it needs.`);
+      config = undefined;
+    }
+    let match = scaffold.emit(config, param.into, param.tests);
+    let patches = match.patches;
+    match.files.forEach(param => {
+      let contents = param.contents;
+      let path = param.path;
+      if (dryRun) {
+        console.log(`Would write: ` + path + ` (` + contents.split("\n").length.toString() + ` lines)`);
+      } else if (Nodefs.existsSync(path)) {
+        console.log(`Skipped (exists): ` + path);
+      } else {
+        Nodefs.mkdirSync(Nodepath.dirname(path), {
+          recursive: true
+        });
+        Nodefs.writeFileSync(path, contents, "utf8");
+        console.log(`Wrote: ` + path);
+      }
+    });
+    if (patches.length !== 0) {
+      console.log("");
+      console.log("── Paste these; they go into files you already own ──────────────");
+      patches.forEach(param => {
+        console.log("");
+        console.log(`# ` + param.into + ` — ` + param.at);
+        console.log(param.contents);
+      });
+      console.log("");
+      console.log("Printed rather than written: placing an arm in an existing ordered `switch`\nis an AST operation, and a text splice into the wrong arm is a bug the\ncompiler cannot see.");
+    }
+    process.exit(0);
+  });
+}
 
 export {
   fail,
   usage,
-  parseFlags,
   splitList,
   arrayFieldNames,
+  parseArgs,
+  cli,
   main,
 }
-/*  Not a pure module */
+/* node:fs Not a pure module */