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

package/src/generator/CertifyTrait.res.mjs

@@ -6,6 +6,8 @@ import * as Nodeurl from "node:url";
 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 Util_Sury$Reventless from "../util/Util_Sury.res.mjs";
 import * as PackageVersion$Reventless from "../PackageVersion.res.mjs";
 import * as TraitCertificate$Reventless from "../components/TraitCertificate.res.mjs";
@@ -60,86 +62,99 @@ function readJson(path) {
   }
 }
 
-async function main() {
-  let argv = process.argv.slice(2, process.argv.length);
-  let flag = key => {
-    let i = argv.indexOf("--" + key);
-    if (i !== -1) {
-      return argv[i + 1 | 0];
-    }
-  };
-  let traitPackage = argv[0];
-  if (traitPackage !== undefined) {
-    switch (traitPackage) {
-      case "" :
-      case "--help" :
-      case "-h" :
-        break;
-      default:
-        let match = flag("host");
-        let match$1 = flag("report");
-        let match$2 = flag("out");
-        if (match === undefined) {
-          return fail("--host, --report and --out are all required.\n\n" + usage);
-        }
-        if (match$1 === undefined) {
-          return fail("--host, --report and --out are all required.\n\n" + usage);
-        }
-        if (match$2 === undefined) {
-          return fail("--host, --report and --out are all required.\n\n" + usage);
-        }
-        let conformanceModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Conformance";
-        let specifier = traitPackage + `/src/` + conformanceModule + `.res.mjs`;
-        let modulePath;
-        try {
-          modulePath = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
-        } catch (exn) {
-          modulePath = specifier;
-        }
-        let conformance;
-        try {
-          conformance = await import(Nodeurl.pathToFileURL(modulePath).href);
-        } catch (exn$1) {
-          fail(traitPackage + ` ships no conformance suite (looked for ` + specifier + `).\n  A trait without one cannot be certified — there is nothing to prove.`);
-          conformance = undefined;
-        }
-        let suite = conformance.suiteName(match);
-        let parsed;
-        try {
-          parsed = Util_Sury$Reventless.fromJson(readJson(match$1), reportSchema);
-        } catch (exn$2) {
-          fail(match$1 + ` is not a Jest JSON report (expected \`testResults\`).`);
-          parsed = undefined;
-        }
-        let results = assertionsFor(parsed, suite);
-        if (results.length === 0) {
-          return fail(`the report contains no suite titled "` + suite + `".\n` + (`  Either the conformance binding was never registered, or ` + match + ` is not the `) + `name its Spec declares.`);
-        }
-        let resolveVersion = specifier => {
-          try {
-            let entry = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
-            return PackageVersion$Reventless.fromModuleUrl(Nodeurl.pathToFileURL(entry).href);
-          } catch (exn) {
-            return "0.0.0";
+function parseArgs(argv) {
+  return Stdlib_Result.flatMap(Stdlib_Result.flatMap(CliArgs$Reventless.parse([
+    "host",
+    "report",
+    "out"
+  ], undefined, undefined, undefined, argv), a => CliArgs$Reventless.atMost(a, 1)), a => {
+    let match = CliArgs$Reventless.positionals(a)[0];
+    let match$1 = CliArgs$Reventless.string(a, "host");
+    let match$2 = CliArgs$Reventless.string(a, "report");
+    let match$3 = CliArgs$Reventless.string(a, "out");
+    if (match !== undefined && match !== "") {
+      if (match$1 !== undefined && match$2 !== undefined && match$3 !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: {
+            traitPackage: match,
+            host: match$1,
+            report: match$2,
+            out: match$3
           }
         };
-        let certificate = TraitCertificate$Reventless.fromReport(traitPackage, resolveVersion(specifier), resolveVersion("@reventlessdev/reventless-spec/package.json"), match, suite, results);
-        Nodefs.writeFileSync(match$2, TraitCertificate$Reventless.render(certificate), "utf8");
-        console.log(`certify-trait: ` + TraitCertificate$Reventless.summarize(certificate));
-        console.log(`Wrote: ` + match$2);
-        if (!TraitCertificate$Reventless.verified(certificate)) {
-          process.exit(1);
-          return;
-        } else {
-          return;
-        }
+      } else {
+        return {
+          TAG: "Error",
+          _0: "--host, --report and --out are all required."
+        };
+      }
+    } else {
+      return {
+        TAG: "Error",
+        _0: "<trait-package> is required."
+      };
     }
-  }
-  console.log(usage);
-  process.exit(argv.length === 0 ? 1 : 0);
+  });
 }
 
-main();
+let cli = {
+  bin: "certify-trait",
+  usage: usage,
+  parse: parseArgs
+};
+
+function main() {
+  return CliArgs$Reventless.run(cli, undefined, undefined, async param => {
+    let out = param.out;
+    let reportPath = param.report;
+    let host = param.host;
+    let traitPackage = param.traitPackage;
+    let conformanceModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Conformance";
+    let specifier = traitPackage + `/src/` + conformanceModule + `.res.mjs`;
+    let modulePath;
+    try {
+      modulePath = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
+    } catch (exn) {
+      modulePath = specifier;
+    }
+    let conformance;
+    try {
+      conformance = await import(Nodeurl.pathToFileURL(modulePath).href);
+    } catch (exn$1) {
+      fail(traitPackage + ` ships no conformance suite (looked for ` + specifier + `).\n  A trait without one cannot be certified — there is nothing to prove.`);
+      conformance = undefined;
+    }
+    let suite = conformance.suiteName(host);
+    let parsed;
+    try {
+      parsed = Util_Sury$Reventless.fromJson(readJson(reportPath), reportSchema);
+    } catch (exn$2) {
+      fail(reportPath + ` is not a Jest JSON report (expected \`testResults\`).`);
+      parsed = undefined;
+    }
+    let results = assertionsFor(parsed, suite);
+    if (results.length === 0) {
+      return fail(`the report contains no suite titled "` + suite + `".\n` + (`  Either the conformance binding was never registered, or ` + host + ` is not the `) + `name its Spec declares.`);
+    }
+    let resolveVersion = specifier => {
+      try {
+        let entry = Nodemodule.createRequire(process.cwd() + "/index.js").resolve(specifier);
+        return PackageVersion$Reventless.fromModuleUrl(Nodeurl.pathToFileURL(entry).href);
+      } catch (exn) {
+        return "0.0.0";
+      }
+    };
+    let certificate = TraitCertificate$Reventless.fromReport(traitPackage, resolveVersion(specifier), resolveVersion("@reventlessdev/reventless-spec/package.json"), host, suite, results);
+    Nodefs.writeFileSync(out, TraitCertificate$Reventless.render(certificate), "utf8");
+    console.log(`certify-trait: ` + TraitCertificate$Reventless.summarize(certificate));
+    console.log(`Wrote: ` + out);
+    if (!TraitCertificate$Reventless.verified(certificate)) {
+      process.exit(1);
+      return;
+    }
+  });
+}
 
 export {
   fail,
@@ -149,6 +164,8 @@ export {
   reportSchema,
   assertionsFor,
   readJson,
+  parseArgs,
+  cli,
   main,
 }
 /* reportAssertionSchema Not a pure module */

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.