@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/FormatterHuman.res

@@ -0,0 +1,138 @@
+// Terminal-coloured human formatter. Shipped as the default output for
+// `reventless-gwt run`. Uses picocolors for ANSI colours — it is a tiny
+// zero-dependency helper that transparently disables colour when stdout
+// is not a TTY.
+
+type colour = string => string
+type picocolors = {
+  red: colour,
+  green: colour,
+  yellow: colour,
+  cyan: colour,
+  gray: colour,
+  bold: colour,
+  dim: colour,
+}
+
+@module("picocolors") external pc: picocolors = "default"
+
+@val external processStdout: {"write": string => unit} = "process.stdout"
+@val external processCwd: unit => string = "process.cwd"
+@module("node:path") external pathBasename: string => string = "basename"
+@module("node:path") external pathRelative: (string, string) => string = "relative"
+
+let write = (s: string) => processStdout["write"](s)
+let writeLine = (s: string) => write(s ++ "\n")
+
+let formatFilePath = (abs: string) => {
+  let base = pathBasename(abs)
+  let name = if String.endsWith(base, ".res.mjs") {
+    String.slice(base, ~start=0, ~end=String.length(base) - 8)
+  } else {
+    base
+  }
+  let rel = pathRelative(processCwd(), abs)
+  `${name} - ${rel}`
+}
+
+let formatLocation = (loc: option<Collector.location>) =>
+  switch loc {
+  | None => ""
+  | Some(l) => `${l.file}:${Int.toString(l.line)}`
+  }
+
+let renderMismatch = (m: Outcome.mismatch) =>
+  switch m {
+  | EventsMismatch({expected, actual}) => {
+      let exp = RenderRescript.renderMany(expected)
+      let act = RenderRescript.renderMany(actual)
+      `  expected: ${exp}\n  actual:   ${act}`
+    }
+  | ErrorMismatch({expected, actual, actualEvents}) => {
+      let exp = `Error(${RenderRescript.render(expected)})`
+      let act = switch actual {
+      | Some(v) => `Error(${RenderRescript.render(v)})`
+      | None => `Ok(${RenderRescript.renderMany(actualEvents)})`
+      }
+      `  expected: ${exp}\n  actual:   ${act}`
+    }
+  | StateMismatch({key, expected, actual}) =>
+    `  key:      "${key}"\n  expected: ${RenderRescript.renderOption(
+        expected,
+      )}\n  actual:   ${RenderRescript.renderOption(actual)}`
+  | NoEventExpected({actual}) =>
+    `  expected no events\n  actual:   ${RenderRescript.renderMany(actual)}`
+  | TodoMismatch({expected, actual}) => {
+      let fmt = (arr: array<(string, JSON.t)>) =>
+        arr
+        ->Array.map(((id, v)) => `(${id}, ${RenderRescript.render(v)})`)
+        ->Array.join(", ")
+      `  expected: [${fmt(expected)}]\n  actual:   [${fmt(actual)}]`
+    }
+  | AppendConditionMismatch({expected, actual}) =>
+    `  expected: ${RenderRescript.render(expected)}\n  actual:   ${RenderRescript.render(
+        actual,
+      )}`
+  | TranslateError({expected, actual}) =>
+    `  expected: ${expected}\n  actual:   ${actual->Option.getOr("(none)")}`
+  | QueryRowsMismatch({expected, actual}) =>
+    `  expected: ${RenderRescript.renderMany(expected)}\n  actual:   ${RenderRescript.renderMany(
+        actual,
+      )}`
+  | PublishedActionsMismatch({expected, actual}) =>
+    `  expected: ${RenderRescript.renderMany(expected)}\n  actual:   ${RenderRescript.renderMany(
+        actual,
+      )}`
+  | Throw({error, stack}) => `  error: ${error}\n${stack}`
+  }
+
+let emitTest = (t: RunnerTypes.testResult) => {
+  let path = t.describePath->Array.join(" > ")
+  let full = path == "" ? t.name : `${path} > ${t.name}`
+  let loc = formatLocation(t.location)
+  let locStr = loc == "" ? "" : ` ${pc.dim(loc)}`
+  switch t.status {
+  | Pass => writeLine(`  ${pc.green("✓")} ${full}${locStr}`)
+  | Skip =>
+    writeLine(
+      `  ${pc.yellow("○")} ${full}${locStr} ${pc.dim(
+          t.skipReason->Option.getOr("skipped"),
+        )}`,
+    )
+  | Fail => {
+      writeLine(`  ${pc.red("✗")} ${pc.bold(full)}${locStr}`)
+      switch t.mismatch {
+      | Some(m) => {
+          writeLine("")
+          writeLine(renderMismatch(m))
+          let hint = Hint.forMismatch(~slice=?t.slice, m)
+          writeLine("")
+          writeLine(`  ${pc.cyan(Hint.format(hint))}`)
+          writeLine("")
+        }
+      | None => ()
+      }
+    }
+  }
+}
+
+let emitFile = (f: RunnerTypes.fileResult) => {
+  writeLine("")
+  writeLine(pc.bold(formatFilePath(f.path)))
+  f.tests->Array.forEach(emitTest)
+}
+
+let emitSummary = (s: RunnerTypes.summary) => {
+  writeLine("")
+  let line = `Tests: ${Int.toString(s.total)}  ${pc.green(
+      Int.toString(s.passed) ++ " passed",
+    )}  ${pc.red(Int.toString(s.failed) ++ " failed")}  ${pc.yellow(
+      Int.toString(s.skipped) ++ " skipped",
+    )}  (${Float.toString(s.durationMs)} ms)`
+  writeLine(line)
+}
+
+let emit = (r: RunnerTypes.runResult) => {
+  r.files->Array.forEach(emitFile)
+  emitSummary(r.summary)
+}

package/src/FormatterHuman.res.mjs

@@ -0,0 +1,122 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import Picocolors from "picocolors";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Hint$ReventlessGwt from "./Hint.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+function write(s) {
+  process.stdout.write(s);
+}
+
+function writeLine(s) {
+  process.stdout.write(s + "\n");
+}
+
+function formatFilePath(abs) {
+  let base = Nodepath.basename(abs);
+  let name = base.endsWith(".res.mjs") ? base.slice(0, base.length - 8 | 0) : base;
+  let rel = Nodepath.relative(process.cwd(), abs);
+  return name + ` - ` + rel;
+}
+
+function formatLocation(loc) {
+  if (loc !== undefined) {
+    return loc.file + `:` + loc.line.toString();
+  } else {
+    return "";
+  }
+}
+
+function renderMismatch(m) {
+  switch (m.TAG) {
+    case "EventsMismatch" :
+      let exp = RenderRescript$ReventlessGwt.renderMany(m.expected);
+      let act = RenderRescript$ReventlessGwt.renderMany(m.actual);
+      return `  expected: ` + exp + `\n  actual:   ` + act;
+    case "ErrorMismatch" :
+      let actual = m.actual;
+      let exp$1 = `Error(` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `)`;
+      let act$1 = actual !== undefined ? `Error(` + RenderRescript$ReventlessGwt.render(undefined, actual) + `)` : `Ok(` + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + `)`;
+      return `  expected: ` + exp$1 + `\n  actual:   ` + act$1;
+    case "StateMismatch" :
+      return `  key:      "` + m.key + `"\n  expected: ` + RenderRescript$ReventlessGwt.renderOption(m.expected) + `\n  actual:   ` + RenderRescript$ReventlessGwt.renderOption(m.actual);
+    case "NoEventExpected" :
+      return `  expected no events\n  actual:   ` + RenderRescript$ReventlessGwt.renderMany(m.actual);
+    case "TodoMismatch" :
+      let fmt = arr => arr.map(param => `(` + param[0] + `, ` + RenderRescript$ReventlessGwt.render(undefined, param[1]) + `)`).join(", ");
+      return `  expected: [` + fmt(m.expected) + `]\n  actual:   [` + fmt(m.actual) + `]`;
+    case "AppendConditionMismatch" :
+      return `  expected: ` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `\n  actual:   ` + RenderRescript$ReventlessGwt.render(undefined, m.actual);
+    case "TranslateError" :
+      return `  expected: ` + m.expected + `\n  actual:   ` + Stdlib_Option.getOr(m.actual, "(none)");
+    case "QueryRowsMismatch" :
+    case "PublishedActionsMismatch" :
+      return `  expected: ` + RenderRescript$ReventlessGwt.renderMany(m.expected) + `\n  actual:   ` + RenderRescript$ReventlessGwt.renderMany(m.actual);
+    case "Throw" :
+      return `  error: ` + m.error + `\n` + m.stack;
+  }
+}
+
+function emitTest(t) {
+  let path = t.describePath.join(" > ");
+  let full = path === "" ? t.name : path + ` > ` + t.name;
+  let loc = formatLocation(t.location);
+  let locStr = loc === "" ? "" : ` ` + Picocolors.dim(loc);
+  let match = t.status;
+  switch (match) {
+    case "Pass" :
+      let s = `  ` + Picocolors.green("✓") + ` ` + full + locStr;
+      return process.stdout.write(s + "\n");
+    case "Fail" :
+      let s$1 = `  ` + Picocolors.red("✗") + ` ` + Picocolors.bold(full) + locStr;
+      process.stdout.write(s$1 + "\n");
+      let m = t.mismatch;
+      if (m === undefined) {
+        return;
+      }
+      process.stdout.write("\n");
+      let s$2 = renderMismatch(m);
+      process.stdout.write(s$2 + "\n");
+      let hint = Hint$ReventlessGwt.forMismatch(t.slice, m);
+      process.stdout.write("\n");
+      let s$3 = `  ` + Picocolors.cyan(Hint$ReventlessGwt.format(hint));
+      process.stdout.write(s$3 + "\n");
+      return process.stdout.write("\n");
+    case "Skip" :
+      let s$4 = `  ` + Picocolors.yellow("○") + ` ` + full + locStr + ` ` + Picocolors.dim(Stdlib_Option.getOr(t.skipReason, "skipped"));
+      return process.stdout.write(s$4 + "\n");
+  }
+}
+
+function emitFile(f) {
+  process.stdout.write("\n");
+  let s = Picocolors.bold(formatFilePath(f.path));
+  process.stdout.write(s + "\n");
+  f.tests.forEach(emitTest);
+}
+
+function emitSummary(s) {
+  process.stdout.write("\n");
+  let s$1 = `Tests: ` + s.total.toString() + `  ` + Picocolors.green(s.passed.toString() + " passed") + `  ` + Picocolors.red(s.failed.toString() + " failed") + `  ` + Picocolors.yellow(s.skipped.toString() + " skipped") + `  (` + s.durationMs.toString() + ` ms)`;
+  process.stdout.write(s$1 + "\n");
+}
+
+function emit(r) {
+  r.files.forEach(emitFile);
+  emitSummary(r.summary);
+}
+
+export {
+  write,
+  writeLine,
+  formatFilePath,
+  formatLocation,
+  renderMismatch,
+  emitTest,
+  emitFile,
+  emitSummary,
+  emit,
+}
+/* node:path Not a pure module */

package/src/FormatterJson.res

@@ -0,0 +1,257 @@
+// Structured JSON formatter — the AI loop's primary input and the substrate
+// for any programmatic consumer. Ships both a single-envelope mode and an
+// NDJSON streaming mode (`--stream`). Shape matches §3.3 of
+// `docs/analysis/given-when-then-specifications.md`.
+
+// 1.1.0 — additive: `PublishedActionsMismatch` mismatch kind for the
+// Delegate_GWT / cross-plugin Flow_GWT boundary steps.
+let schemaVersion = "1.1.0"
+
+@val external processStdout: {"write": string => unit} = "process.stdout"
+let write = (s: string) => processStdout["write"](s)
+let writeLine = (s: string) => write(s ++ "\n")
+
+// Re-render a JSON value as a dual-rendered `{type, payload, rendered}` entry.
+let renderValue = (j: JSON.t): JSON.t => {
+  let obj = Dict.make()
+  switch j {
+  | Object(dict) =>
+    switch dict->Dict.get("TAG") {
+    | Some(String(tag)) => {
+        obj->Dict.set("type", JSON.Encode.string(tag))
+        let payloadKeys =
+          dict
+          ->Dict.keysToArray
+          ->Array.filter(k => k != "TAG" && String.startsWith(k, "_"))
+        let payload = switch payloadKeys {
+        | [] => JSON.Encode.null
+        | ["_0"] =>
+          dict->Dict.get("_0")->Option.getOr(JSON.Encode.null)
+        | _ => {
+            let payloadDict = Dict.make()
+            payloadKeys->Array.forEach(k =>
+              payloadDict->Dict.set(
+                k,
+                dict->Dict.get(k)->Option.getOr(JSON.Encode.null),
+              )
+            )
+            JSON.Encode.object(payloadDict)
+          }
+        }
+        obj->Dict.set("payload", payload)
+      }
+    | _ => {
+        obj->Dict.set("type", JSON.Encode.null)
+        obj->Dict.set("payload", j)
+      }
+    }
+  | String(s) => {
+      obj->Dict.set("type", JSON.Encode.string(s))
+      obj->Dict.set("payload", JSON.Encode.null)
+    }
+  | _ => {
+      obj->Dict.set("type", JSON.Encode.null)
+      obj->Dict.set("payload", j)
+    }
+  }
+  obj->Dict.set("rendered", JSON.Encode.string(RenderRescript.render(j)))
+  JSON.Encode.object(obj)
+}
+
+let renderValues = (arr: array<JSON.t>): JSON.t =>
+  arr->Array.map(renderValue)->JSON.Encode.array
+
+let mismatchJson = (m: Outcome.mismatch, slice: option<string>): JSON.t => {
+  let obj = Dict.make()
+  obj->Dict.set("kind", JSON.Encode.string(Outcome.kindName(m)))
+  let optVal = o =>
+    switch o {
+    | Some(v) => renderValue(v)
+    | None => JSON.Encode.null
+    }
+  switch m {
+  | EventsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", renderValues(expected))
+      obj->Dict.set("actual", renderValues(actual))
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diffArrays(expected, actual)))
+    }
+  | ErrorMismatch({expected, actual, actualEvents}) => {
+      obj->Dict.set("expected", renderValue(expected))
+      obj->Dict.set("actual", optVal(actual))
+      obj->Dict.set("actualEvents", renderValues(actualEvents))
+    }
+  | StateMismatch({key, expected, actual}) => {
+      obj->Dict.set("key", JSON.Encode.string(key))
+      obj->Dict.set("expected", optVal(expected))
+      obj->Dict.set("actual", optVal(actual))
+      let eJson = expected->Option.getOr(JSON.Encode.null)
+      let aJson = actual->Option.getOr(JSON.Encode.null)
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diff(eJson, aJson)))
+    }
+  | NoEventExpected({actual}) => obj->Dict.set("actual", renderValues(actual))
+  | TodoMismatch({expected, actual}) => {
+      let pairArr = pairs =>
+        pairs
+        ->Array.map(((id, v)) => {
+          let d = Dict.make()
+          d->Dict.set("id", JSON.Encode.string(id))
+          d->Dict.set("value", renderValue(v))
+          JSON.Encode.object(d)
+        })
+        ->JSON.Encode.array
+      obj->Dict.set("expected", pairArr(expected))
+      obj->Dict.set("actual", pairArr(actual))
+    }
+  | AppendConditionMismatch({expected, actual}) => {
+      obj->Dict.set("expected", expected)
+      obj->Dict.set("actual", actual)
+    }
+  | TranslateError({expected, actual}) => {
+      obj->Dict.set("expected", JSON.Encode.string(expected))
+      obj->Dict.set(
+        "actual",
+        actual->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+      )
+    }
+  | QueryRowsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", renderValues(expected))
+      obj->Dict.set("actual", renderValues(actual))
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diffArrays(expected, actual)))
+    }
+  | PublishedActionsMismatch({expected, actual}) => {
+      obj->Dict.set("expected", renderValues(expected))
+      obj->Dict.set("actual", renderValues(actual))
+      obj->Dict.set("fieldDiff", Diff.toJsonArray(Diff.diffArrays(expected, actual)))
+    }
+  | Throw({error, stack}) => {
+      obj->Dict.set("error", JSON.Encode.string(error))
+      obj->Dict.set("stack", JSON.Encode.string(stack))
+    }
+  }
+  let hint = Hint.forMismatch(~slice?, m)
+  obj->Dict.set("hint", Hint.toJson(hint))
+  JSON.Encode.object(obj)
+}
+
+let locationJson = (loc: option<Collector.location>): JSON.t =>
+  switch loc {
+  | None => JSON.Encode.null
+  | Some(l) => {
+      let d = Dict.make()
+      d->Dict.set("file", JSON.Encode.string(l.file))
+      d->Dict.set("line", JSON.Encode.int(l.line))
+      d->Dict.set("column", JSON.Encode.int(l.column))
+      JSON.Encode.object(d)
+    }
+  }
+
+let testJson = (t: RunnerTypes.testResult): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("id", JSON.Encode.string(t.id))
+  d->Dict.set("name", JSON.Encode.string(t.name))
+  d->Dict.set(
+    "describePath",
+    t.describePath->Array.map(JSON.Encode.string)->JSON.Encode.array,
+  )
+  d->Dict.set("status", JSON.Encode.string(RunnerTypes.statusString(t.status)))
+  d->Dict.set("durationMs", JSON.Encode.float(t.durationMs))
+  d->Dict.set("location", locationJson(t.location))
+  switch t.mismatch {
+  | Some(m) => d->Dict.set("mismatch", mismatchJson(m, t.slice))
+  | None => ()
+  }
+  switch t.skipReason {
+  | Some(r) => d->Dict.set("skipReason", JSON.Encode.string(r))
+  | None => ()
+  }
+  JSON.Encode.object(d)
+}
+
+let fileJson = (f: RunnerTypes.fileResult): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("path", JSON.Encode.string(f.path))
+  d->Dict.set("tests", f.tests->Array.map(testJson)->JSON.Encode.array)
+  JSON.Encode.object(d)
+}
+
+let summaryJson = (s: RunnerTypes.summary): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("total", JSON.Encode.int(s.total))
+  d->Dict.set("passed", JSON.Encode.int(s.passed))
+  d->Dict.set("failed", JSON.Encode.int(s.failed))
+  d->Dict.set("skipped", JSON.Encode.int(s.skipped))
+  d->Dict.set("files", JSON.Encode.int(s.files))
+  JSON.Encode.object(d)
+}
+
+let envelope = (r: RunnerTypes.runResult, ~toolVersion: string): JSON.t => {
+  let d = Dict.make()
+  d->Dict.set("schemaVersion", JSON.Encode.string(schemaVersion))
+  d->Dict.set("tool", JSON.Encode.string("reventless-gwt"))
+  d->Dict.set("toolVersion", JSON.Encode.string(toolVersion))
+  d->Dict.set("startedAt", JSON.Encode.string(r.summary.startedAt))
+  d->Dict.set("durationMs", JSON.Encode.float(r.summary.durationMs))
+  d->Dict.set("summary", summaryJson(r.summary))
+  d->Dict.set("files", r.files->Array.map(fileJson)->JSON.Encode.array)
+  JSON.Encode.object(d)
+}
+
+let emit = (r: RunnerTypes.runResult, ~toolVersion: string) =>
+  write(JSON.stringify(envelope(r, ~toolVersion), ~space=2) ++ "\n")
+
+// Streaming variant — NDJSON events.
+let streamRunStart = (~toolVersion: string, ~startedAt: string) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("runStarted"))
+  d->Dict.set("schemaVersion", JSON.Encode.string(schemaVersion))
+  d->Dict.set("toolVersion", JSON.Encode.string(toolVersion))
+  d->Dict.set("at", JSON.Encode.string(startedAt))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamFileStart = (path: string) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("fileStarted"))
+  d->Dict.set("path", JSON.Encode.string(path))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamTest = (t: RunnerTypes.testResult) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("testResult"))
+  let tj = testJson(t)
+  // Fold testJson's object keys into the envelope.
+  switch tj {
+  | Object(inner) =>
+    inner->Dict.keysToArray->Array.forEach(k =>
+      d->Dict.set(k, inner->Dict.getUnsafe(k))
+    )
+  | _ => ()
+  }
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamFileFinished = (f: RunnerTypes.fileResult) => {
+  let passed = ref(0)
+  let failed = ref(0)
+  f.tests->Array.forEach(t =>
+    switch t.status {
+    | Pass => passed := passed.contents + 1
+    | Fail => failed := failed.contents + 1
+    | Skip => ()
+    }
+  )
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("fileFinished"))
+  d->Dict.set("path", JSON.Encode.string(f.path))
+  d->Dict.set("passed", JSON.Encode.int(passed.contents))
+  d->Dict.set("failed", JSON.Encode.int(failed.contents))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}
+
+let streamRunEnd = (r: RunnerTypes.runResult) => {
+  let d = Dict.make()
+  d->Dict.set("type", JSON.Encode.string("runFinished"))
+  d->Dict.set("summary", summaryJson(r.summary))
+  writeLine(JSON.stringify(JSON.Encode.object(d)))
+}