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

package/src/generator/CertifyTrait.res

@@ -83,106 +83,109 @@ let readJson = (path: string) =>
 
 // ── Entry point ──────────────────────────────────────────────────────────────
 
-let main = async () => {
-  let argv = NodeProcess.argv->Array.slice(~start=2, ~end=NodeProcess.argv->Array.length)
-  let flag = key =>
-    switch argv->Array.indexOf("--" ++ key) {
-    | -1 => None
-    | i => argv->Array.get(i + 1)
+type args = {traitPackage: string, host: string, report: string, out: string}
+
+let parseArgs = (argv: array<string>): result<args, string> =>
+  CliArgs.parse(~strings=["host", "report", "out"], argv)
+  ->Result.flatMap(a => a->CliArgs.atMost(1))
+  ->Result.flatMap(a =>
+    switch (
+      a->CliArgs.positionals->Array.get(0),
+      a->CliArgs.string("host"),
+      a->CliArgs.string("report"),
+      a->CliArgs.string("out"),
+    ) {
+    | (None | Some(""), _, _, _) => Error("<trait-package> is required.")
+    | (Some(traitPackage), Some(host), Some(report), Some(out)) =>
+      Ok({traitPackage, host, report, out})
+    | (Some(_), _, _, _) => Error("--host, --report and --out are all required.")
     }
+  )
 
-  switch argv->Array.get(0) {
-  | None | Some("") | Some("--help") | Some("-h") => {
-      Console.log(usage)
-      NodeProcess.exit(argv->Array.length == 0 ? 1 : 0)
+let cli: CliArgs.cli<args> = {bin: "certify-trait", usage, parse: parseArgs}
+
+let main = () =>
+  CliArgs.run(cli, async ({traitPackage, host, report: reportPath, out}) => {
+    // `@scope/trait-attachments` → `Attachments_Conformance`, the same
+    // derivation `graft-trait` does for `_Scaffold`.
+    let conformanceModule =
+      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("") ++ "_Conformance"
+    let specifier = `${traitPackage}/src/${conformanceModule}.res.mjs`
+    // Resolved from the **caller's** directory: the trait is a dependency of
+    // the plugin being certified and deliberately not one of this package.
+    let modulePath = try NodeModule.createRequire(
+      NodeProcess.cwd() ++ "/index.js",
+    )->NodeModule.requireResolve(specifier) catch {
+    | _ => specifier
+    }
+    let conformance: conformanceExports = try await dynImport(
+      NodeUrl.pathToFileURL(modulePath)["href"],
+    ) catch {
+    | _ =>
+      fail(
+        `${traitPackage} ships no conformance suite (looked for ${specifier}).\n` ++ `  A trait without one cannot be certified — there is nothing to prove.`,
+      )
+      %raw(`undefined`)
     }
-  | Some(traitPackage) =>
-    switch (flag("host"), flag("report"), flag("out")) {
-    | (None, _, _) | (_, None, _) | (_, _, None) =>
-      fail("--host, --report and --out are all required.\n\n" ++ usage)
-    | (Some(host), Some(reportPath), Some(out)) => {
-        // `@scope/trait-attachments` → `Attachments_Conformance`, the same
-        // derivation `graft-trait` does for `_Scaffold`.
-        let conformanceModule =
-          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("") ++ "_Conformance"
-        let specifier = `${traitPackage}/src/${conformanceModule}.res.mjs`
-        // Resolved from the **caller's** directory: the trait is a dependency of
-        // the plugin being certified and deliberately not one of this package.
-        let modulePath = try NodeModule.createRequire(
-          NodeProcess.cwd() ++ "/index.js",
-        )->NodeModule.requireResolve(specifier) catch {
-        | _ => specifier
-        }
-        let conformance: conformanceExports = try await dynImport(
-          NodeUrl.pathToFileURL(modulePath)["href"],
-        ) catch {
-        | _ =>
-          fail(
-            `${traitPackage} ships no conformance suite (looked for ${specifier}).\n` ++ `  A trait without one cannot be certified — there is nothing to prove.`,
-          )
-          %raw(`undefined`)
-        }
 
-        let suite = conformance.suiteName(host)
-        let parsed = switch readJson(reportPath)->Util_Sury.fromJson(reportSchema) {
-        | value => value
-        | exception _ =>
-          fail(`${reportPath} is not a Jest JSON report (expected \`testResults\`).`)
-          %raw(`undefined`)
-        }
+    let suite = conformance.suiteName(host)
+    let parsed = switch readJson(reportPath)->Util_Sury.fromJson(reportSchema) {
+    | value => value
+    | exception _ =>
+      fail(`${reportPath} is not a Jest JSON report (expected \`testResults\`).`)
+      %raw(`undefined`)
+    }
 
-        switch parsed->assertionsFor(~suite) {
-        // The failure worth catching. A green build that never ran the suite
-        // looks exactly like one that ran it and passed, so silence is refused
-        // rather than certified as zero-of-zero.
-        | [] =>
-          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.`,
-          )
-        | results => {
-            let resolveVersion = specifier =>
-              try {
-                let entry =
-                  NodeModule.createRequire(
-                    NodeProcess.cwd() ++ "/index.js",
-                  )->NodeModule.requireResolve(specifier)
-                PackageVersion.fromModuleUrl(NodeUrl.pathToFileURL(entry)["href"])
-              } catch {
-              | _ => "0.0.0"
-              }
-
-            let certificate = TraitCertificate.fromReport(
-              ~trait=traitPackage,
-              ~traitVersion=resolveVersion(specifier),
-              // The framework the suite ran against, read the same way — a trait
-              // is certified against a version, never in the abstract.
-              ~framework=resolveVersion("@reventlessdev/reventless-spec/package.json"),
-              ~host,
-              ~suite,
-              ~results,
-            )
-            NodeFs.writeFileSync(out, certificate->TraitCertificate.render)
-            Console.log(`certify-trait: ${certificate->TraitCertificate.summarize}`)
-            Console.log(`Wrote: ${out}`)
-            if !(certificate->TraitCertificate.verified) {
-              NodeProcess.exit(1)
-            }
+    switch parsed->assertionsFor(~suite) {
+    // The failure worth catching. A green build that never ran the suite
+    // looks exactly like one that ran it and passed, so silence is refused
+    // rather than certified as zero-of-zero.
+    | [] =>
+      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.`,
+      )
+    | results => {
+        let resolveVersion = specifier =>
+          try {
+            let entry =
+              NodeModule.createRequire(NodeProcess.cwd() ++ "/index.js")->NodeModule.requireResolve(
+                specifier,
+              )
+            PackageVersion.fromModuleUrl(NodeUrl.pathToFileURL(entry)["href"])
+          } catch {
+          | _ => "0.0.0"
           }
+
+        let certificate = TraitCertificate.fromReport(
+          ~trait=traitPackage,
+          ~traitVersion=resolveVersion(specifier),
+          // The framework the suite ran against, read the same way — a trait
+          // is certified against a version, never in the abstract.
+          ~framework=resolveVersion("@reventlessdev/reventless-spec/package.json"),
+          ~host,
+          ~suite,
+          ~results,
+        )
+        NodeFs.writeFileSync(out, certificate->TraitCertificate.render)
+        Console.log(`certify-trait: ${certificate->TraitCertificate.summarize}`)
+        Console.log(`Wrote: ${out}`)
+        if !(certificate->TraitCertificate.verified) {
+          NodeProcess.exit(1)
         }
       }
     }
-  }
-}
+  })
 
-main()->Promise.ignore
+// No top-level call: `../../run-certify-trait.mjs` invokes [main], so a test can
+// import this module.

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 */