@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Collector.res

@@ -0,0 +1,212 @@
+// Module-level collector used by the CLI runner.
+//
+// When the CLI loads a test file via dynamic import, each `describe`/`test`
+// call routes through `Bind` or `JestBind` and pushes an entry into this
+// collector. After the import resolves (all registrations complete), the CLI
+// drains the entries, executes each body asynchronously, and feeds the results
+// into a formatter.
+//
+// Activation is toggled by the CLI — when inactive, `JestBind` falls back to
+// Jest globals, so existing Jest test runs are unaffected.
+
+type status = Skipped | Runnable | Only
+
+type location = {
+  file: string,
+  line: int,
+  column: int,
+}
+
+type entry = {
+  id: string,
+  name: string,
+  describePath: array<string>,
+  slice: option<string>,
+  body: unit => promise<Outcome.outcome>,
+  status: status,
+  location: option<location>,
+  // Per-test deadline in ms (from `~timeout` on `testPromise`). `None` = use the
+  // runner default. The CLI runner races the body against this; the Jest arm
+  // passes it to Jest's own timeout instead.
+  timeout: option<int>,
+}
+
+let active = ref(false)
+let describeStack: ref<array<string>> = ref([])
+let entries: ref<array<entry>> = ref([])
+let hasOnly = ref(false)
+let skipNext = ref(false)
+let onlyNext = ref(false)
+let skipDepth = ref(0)
+let currentFile: ref<option<string>> = ref(None)
+
+let activate = () => {
+  active := true
+  describeStack := []
+  entries := []
+  hasOnly := false
+  skipNext := false
+  onlyNext := false
+  // Reset the skip nesting depth too: a throwing `xdescribe` body in a prior
+  // file could otherwise leave it > 0, silently skipping every test in every
+  // subsequently loaded file.
+  skipDepth := 0
+  currentFile := None
+}
+
+let deactivate = () => active := false
+let isActive = () => active.contents
+
+let setCurrentFile = path => currentFile := Some(path)
+let getCurrentFile = () => currentFile.contents
+
+let markSkipNext = () => skipNext := true
+let markOnlyNext = () => {
+  onlyNext := true
+  hasOnly := true
+}
+
+let pushDescribe = (label: string, body: unit => unit) => {
+  describeStack := Array.concat(describeStack.contents, [label])
+  body()
+  let ds = describeStack.contents
+  describeStack := ds->Array.slice(~start=0, ~end=ds->Array.length - 1)
+}
+
+let buildId = (describePath, name) => {
+  let prefix = describePath->Array.join("::")
+  prefix == "" ? name : prefix ++ "::" ++ name
+}
+
+let push = (
+  ~slice=?,
+  ~location=?,
+  ~timeout=?,
+  name: string,
+  body: unit => promise<Outcome.outcome>,
+) => {
+  let status = if skipDepth.contents > 0 {
+    Skipped
+  } else if skipNext.contents {
+    skipNext := false
+    Skipped
+  } else if onlyNext.contents {
+    onlyNext := false
+    Only
+  } else {
+    Runnable
+  }
+  let describePath = describeStack.contents
+  let id = buildId(describePath, name)
+  let entry = {
+    id,
+    name,
+    describePath,
+    slice,
+    body,
+    status,
+    location,
+    timeout,
+  }
+  entries.contents->Array.push(entry)
+}
+
+// A `todo` placeholder: a spec-less slice still ships a discoverable, compiling
+// `_GWT.res`. Register it as a Skipped entry with a no-op passing body so the
+// CLI runner lists it without executing or failing.
+let pushTodo = (name: string) => {
+  let describePath = describeStack.contents
+  let id = buildId(describePath, name)
+  let entry = {
+    id,
+    name,
+    describePath,
+    slice: None,
+    body: () => Promise.resolve(Outcome.pass),
+    status: Skipped,
+    location: None,
+    timeout: None,
+  }
+  entries.contents->Array.push(entry)
+}
+
+let drain = () => {
+  let result = entries.contents
+  entries := []
+  describeStack := []
+  result
+}
+
+// Parse a single V8 stack frame line like:
+//   "    at body (/abs/path/File.res.mjs:42:13)"
+//   "    at /abs/path/File.res.mjs:42:13"
+// Returns (file, line, column) if the frame belongs to a non-internal user file.
+let parseFrame = (frame: string): option<location> => {
+  let trimmed = frame->String.trim
+  let body = if String.startsWith(trimmed, "at ") {
+    String.slice(trimmed, ~start=3, ~end=String.length(trimmed))
+  } else {
+    trimmed
+  }
+  let withLoc = switch String.lastIndexOf(body, "(") {
+  | -1 => body
+  | i =>
+    let rest = String.slice(body, ~start=i + 1, ~end=String.length(body))
+    switch String.lastIndexOf(rest, ")") {
+    | -1 => rest
+    | j => String.slice(rest, ~start=0, ~end=j)
+    }
+  }
+  let parts = withLoc->String.split(":")
+  let n = parts->Array.length
+  if n < 3 {
+    None
+  } else {
+    let col = parts->Array.getUnsafe(n - 1)->Int.fromString
+    let line = parts->Array.getUnsafe(n - 2)->Int.fromString
+    let file =
+      parts->Array.slice(~start=0, ~end=n - 2)->Array.join(":")
+    let file = if String.startsWith(file, "file://") {
+      String.slice(file, ~start=7, ~end=String.length(file))
+    } else {
+      file
+    }
+    // Strip the Loader's `?t=N` cache-busting query so locations point at the
+    // real file path.
+    let file = switch String.indexOf(file, "?") {
+    | -1 => file
+    | q => String.slice(file, ~start=0, ~end=q)
+    }
+    switch (line, col) {
+    | (Some(l), Some(c)) => Some({file, line: l, column: c})
+    | _ => None
+    }
+  }
+}
+
+// Walk a captured stack and return the first frame that lives in a test
+// file outside the reventless-gwt package itself.
+let captureLocation = (skip: int): option<location> => {
+  let stack: option<string> = %raw(`(new Error()).stack`)
+  switch stack {
+  | None => None
+  | Some(s) =>
+    let lines = s->String.split("\n")
+    let total = lines->Array.length
+    // Skip the "Error" header, plus `skip` internal frames.
+    let rec find = i =>
+      if i >= total {
+        None
+      } else {
+        let frame = lines->Array.getUnsafe(i)
+        switch parseFrame(frame) {
+        | Some(loc)
+          if !(loc.file->String.includes("reventless-gwt/src/")) &&
+            !(loc.file->String.includes("node_modules/")) =>
+          Some(loc)
+        | _ => find(i + 1)
+        }
+      }
+    find(skip + 1)
+  }
+}

package/src/Collector.res.mjs

@@ -0,0 +1,218 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+
+let active = {
+  contents: false
+};
+
+let describeStack = {
+  contents: []
+};
+
+let entries = {
+  contents: []
+};
+
+let hasOnly = {
+  contents: false
+};
+
+let skipNext = {
+  contents: false
+};
+
+let onlyNext = {
+  contents: false
+};
+
+let skipDepth = {
+  contents: 0
+};
+
+let currentFile = {
+  contents: undefined
+};
+
+function activate() {
+  active.contents = true;
+  describeStack.contents = [];
+  entries.contents = [];
+  hasOnly.contents = false;
+  skipNext.contents = false;
+  onlyNext.contents = false;
+  skipDepth.contents = 0;
+  currentFile.contents = undefined;
+}
+
+function deactivate() {
+  active.contents = false;
+}
+
+function isActive() {
+  return active.contents;
+}
+
+function setCurrentFile(path) {
+  currentFile.contents = path;
+}
+
+function getCurrentFile() {
+  return currentFile.contents;
+}
+
+function markSkipNext() {
+  skipNext.contents = true;
+}
+
+function markOnlyNext() {
+  onlyNext.contents = true;
+  hasOnly.contents = true;
+}
+
+function pushDescribe(label, body) {
+  describeStack.contents = describeStack.contents.concat([label]);
+  body();
+  let ds = describeStack.contents;
+  describeStack.contents = ds.slice(0, ds.length - 1 | 0);
+}
+
+function buildId(describePath, name) {
+  let prefix = describePath.join("::");
+  if (prefix === "") {
+    return name;
+  } else {
+    return prefix + "::" + name;
+  }
+}
+
+function push(slice, location, timeout, name, body) {
+  let status = skipDepth.contents > 0 ? "Skipped" : (
+      skipNext.contents ? (skipNext.contents = false, "Skipped") : (
+          onlyNext.contents ? (onlyNext.contents = false, "Only") : "Runnable"
+        )
+    );
+  let describePath = describeStack.contents;
+  let id = buildId(describePath, name);
+  let entry = {
+    id: id,
+    name: name,
+    describePath: describePath,
+    slice: slice,
+    body: body,
+    status: status,
+    location: location,
+    timeout: timeout
+  };
+  entries.contents.push(entry);
+}
+
+function pushTodo(name) {
+  let describePath = describeStack.contents;
+  let id = buildId(describePath, name);
+  let entry_body = () => Promise.resolve(Outcome$ReventlessGwt.pass);
+  let entry = {
+    id: id,
+    name: name,
+    describePath: describePath,
+    slice: undefined,
+    body: entry_body,
+    status: "Skipped",
+    location: undefined,
+    timeout: undefined
+  };
+  entries.contents.push(entry);
+}
+
+function drain() {
+  let result = entries.contents;
+  entries.contents = [];
+  describeStack.contents = [];
+  return result;
+}
+
+function parseFrame(frame) {
+  let trimmed = frame.trim();
+  let body = trimmed.startsWith("at ") ? trimmed.slice(3, trimmed.length) : trimmed;
+  let i = body.lastIndexOf("(");
+  let withLoc;
+  if (i !== -1) {
+    let rest = body.slice(i + 1 | 0, body.length);
+    let j = rest.lastIndexOf(")");
+    withLoc = j !== -1 ? rest.slice(0, j) : rest;
+  } else {
+    withLoc = body;
+  }
+  let parts = withLoc.split(":");
+  let n = parts.length;
+  if (n < 3) {
+    return;
+  }
+  let col = Stdlib_Int.fromString(parts[n - 1 | 0], undefined);
+  let line = Stdlib_Int.fromString(parts[n - 2 | 0], undefined);
+  let file = parts.slice(0, n - 2 | 0).join(":");
+  let file$1 = file.startsWith("file://") ? file.slice(7, file.length) : file;
+  let q = file$1.indexOf("?");
+  let file$2 = q !== -1 ? file$1.slice(0, q) : file$1;
+  if (line !== undefined && col !== undefined) {
+    return {
+      file: file$2,
+      line: line,
+      column: col
+    };
+  }
+}
+
+function captureLocation(skip) {
+  let stack = ((new Error()).stack);
+  if (stack === undefined) {
+    return;
+  }
+  let lines = stack.split("\n");
+  let total = lines.length;
+  let _i = skip + 1 | 0;
+  while (true) {
+    let i = _i;
+    if (i >= total) {
+      return;
+    }
+    let frame = lines[i];
+    let loc = parseFrame(frame);
+    if (loc !== undefined) {
+      if (!loc.file.includes("reventless-gwt/src/") && !loc.file.includes("node_modules/")) {
+        return loc;
+      }
+      _i = i + 1 | 0;
+      continue;
+    }
+    _i = i + 1 | 0;
+    continue;
+  };
+}
+
+export {
+  active,
+  describeStack,
+  entries,
+  hasOnly,
+  skipNext,
+  onlyNext,
+  skipDepth,
+  currentFile,
+  activate,
+  deactivate,
+  isActive,
+  setCurrentFile,
+  getCurrentFile,
+  markSkipNext,
+  markOnlyNext,
+  pushDescribe,
+  buildId,
+  push,
+  pushTodo,
+  drain,
+  parseFrame,
+  captureLocation,
+}
+/* No side effect */

package/src/ComponentMeta.res

@@ -0,0 +1,77 @@
+// Pure helpers mapping a file path to its Reventless component {kind, name}
+// using the folder-name convention (the same vocabulary the plugin generator
+// classifies by). Shared by the discovery `item` annotation (FormatterVsCode)
+// and the src/ component inventory (ComponentScan). No I/O — path strings only.
+
+type component = {kind: string, name: string}
+
+// The folder→kind vocabulary and body-file suffixes are the single source in
+// `Reventless.ComponentKind` (shared with the plugin generator). Deriving from it
+// means the gwt discovery recognises exactly the folder spellings the generator
+// classifies — including the plural / short forms this file used to miss.
+module Kind = Reventless.ComponentKind
+
+// Strip a body-file suffix (longest first) to recover the spec stem, so spec and
+// body files in one folder collapse to the same component name.
+let stripBody = (stem: string) =>
+  switch Kind.bodySuffixes->Array.find(suf => String.endsWith(stem, suf)) {
+  | Some(suf) => String.slice(stem, ~start=0, ~end=String.length(stem) - String.length(suf))
+  | None => stem
+  }
+
+// Strip the GWT test marker (`_GWT` / `GwtTest` / `Gwt`) — the three shapes
+// `Discovery.isGwtTestFile` recognises.
+let stripGwt = (stem: string) =>
+  if String.endsWith(stem, "_GWT") {
+    String.slice(stem, ~start=0, ~end=String.length(stem) - 4)
+  } else if String.endsWith(stem, "GwtTest") {
+    String.slice(stem, ~start=0, ~end=String.length(stem) - 7)
+  } else if String.endsWith(stem, "Gwt") {
+    String.slice(stem, ~start=0, ~end=String.length(stem) - 3)
+  } else {
+    stem
+  }
+
+// Last path segment (POSIX paths — the monorepo's tooling normalises to `/`).
+let basename = (path: string) =>
+  switch path->String.split("/")->Array.last {
+  | Some(s) => s
+  | None => path
+  }
+
+// Parent folder name (the segment before the filename), if any.
+let parentFolder = (path: string) => {
+  let segs = path->String.split("/")
+  let n = segs->Array.length
+  n >= 2 ? segs->Array.get(n - 2) : None
+}
+
+// Strip the compiled / source extension from a filename.
+let stem = (filename: string) =>
+  if String.endsWith(filename, ".res.mjs") {
+    String.slice(filename, ~start=0, ~end=String.length(filename) - 8)
+  } else if String.endsWith(filename, ".res.js") {
+    String.slice(filename, ~start=0, ~end=String.length(filename) - 7)
+  } else if String.endsWith(filename, ".resi") {
+    String.slice(filename, ~start=0, ~end=String.length(filename) - 5)
+  } else if String.endsWith(filename, ".res") {
+    String.slice(filename, ~start=0, ~end=String.length(filename) - 4)
+  } else {
+    filename
+  }
+
+// {kind, name} for a discovered GWT test file, or None if it isn't inside a
+// recognised kind folder. `kind` is the canonical folder name, so a plural
+// folder (`Aggregates/`) reports the same kind as its singular form.
+let componentOfTestFile = (path: string): option<component> =>
+  switch parentFolder(path)->Option.flatMap(Kind.folderToKind) {
+  | Some(kind) => Some({kind: Kind.folderName(kind), name: path->basename->stem->stripGwt->stripBody})
+  | None => None
+  }
+
+// {kind, name} for a src/ component file (spec or body), or None.
+let componentOfSrcFile = (path: string): option<component> =>
+  switch parentFolder(path)->Option.flatMap(Kind.folderToKind) {
+  | Some(kind) => Some({kind: Kind.folderName(kind), name: path->basename->stem->stripBody})
+  | None => None
+  }

package/src/ComponentMeta.res.mjs

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 ComponentKind$Reventless from "@reventlessdev/reventless-spec/src/components/ComponentKind.res.mjs";
+
+function stripBody(stem) {
+  let suf = ComponentKind$Reventless.bodySuffixes.find(suf => stem.endsWith(suf));
+  if (suf !== undefined) {
+    return stem.slice(0, stem.length - suf.length | 0);
+  } else {
+    return stem;
+  }
+}
+
+function stripGwt(stem) {
+  if (stem.endsWith("_GWT")) {
+    return stem.slice(0, stem.length - 4 | 0);
+  } else if (stem.endsWith("GwtTest")) {
+    return stem.slice(0, stem.length - 7 | 0);
+  } else if (stem.endsWith("Gwt")) {
+    return stem.slice(0, stem.length - 3 | 0);
+  } else {
+    return stem;
+  }
+}
+
+function basename(path) {
+  let s = Stdlib_Array.last(path.split("/"));
+  if (s !== undefined) {
+    return s;
+  } else {
+    return path;
+  }
+}
+
+function parentFolder(path) {
+  let segs = path.split("/");
+  let n = segs.length;
+  if (n >= 2) {
+    return segs[n - 2 | 0];
+  }
+}
+
+function stem(filename) {
+  if (filename.endsWith(".res.mjs")) {
+    return filename.slice(0, filename.length - 8 | 0);
+  } else if (filename.endsWith(".res.js")) {
+    return filename.slice(0, filename.length - 7 | 0);
+  } else if (filename.endsWith(".resi")) {
+    return filename.slice(0, filename.length - 5 | 0);
+  } else if (filename.endsWith(".res")) {
+    return filename.slice(0, filename.length - 4 | 0);
+  } else {
+    return filename;
+  }
+}
+
+function componentOfTestFile(path) {
+  let kind = Stdlib_Option.flatMap(parentFolder(path), ComponentKind$Reventless.folderToKind);
+  if (kind !== undefined) {
+    return {
+      kind: ComponentKind$Reventless.folderName(kind),
+      name: stripBody(stripGwt(stem(basename(path))))
+    };
+  }
+}
+
+function componentOfSrcFile(path) {
+  let kind = Stdlib_Option.flatMap(parentFolder(path), ComponentKind$Reventless.folderToKind);
+  if (kind !== undefined) {
+    return {
+      kind: ComponentKind$Reventless.folderName(kind),
+      name: stripBody(stem(basename(path)))
+    };
+  }
+}
+
+let Kind;
+
+export {
+  Kind,
+  stripBody,
+  stripGwt,
+  basename,
+  parentFolder,
+  stem,
+  componentOfTestFile,
+  componentOfSrcFile,
+}
+/* No side effect */

package/src/ComponentScan.res

@@ -0,0 +1,103 @@
+// Walks each owning package's src/ tree and enumerates its Reventless
+// components by folder convention — including components with no GWT tests.
+// This is the inventory the `components` NDJSON event carries: the basis for
+// the activity-bar Plugin→kind→component tree and "untested slice" coverage.
+// Computed fresh per discovery so it never drifts as components are added.
+
+type component = {
+  // Absolute directory of the owning package (matches the `dir` in `packages`).
+  dir: string,
+  kind: string,
+  name: string,
+  // Absolute paths of the component's `src/` files (spec + body files like
+  // `*_Behavior.res` / `*_Mappings.res`), in walk order. Lets the client list
+  // spec / implementation files under each component node.
+  files: array<string>,
+}
+
+type dirent = {
+  name: string,
+  @as("isDirectory") _isDirectory: unit => bool,
+  @as("isFile") _isFile: unit => bool,
+}
+type readdirOpts = {withFileTypes: bool}
+@module("node:fs/promises")
+external _readdir: (string, readdirOpts) => promise<array<dirent>> = "readdir"
+@module("node:fs") external _existsSync: string => bool = "existsSync"
+@module("node:path") external join: (string, string) => string = "join"
+
+let ignoreNames = ["node_modules", ".git", "dist", "lib", ".history"]
+let shouldIgnore = (name: string) => Array.includes(ignoreNames, name)
+
+// A directory carrying this sentinel file — and its whole subtree — is pruned
+// from the component scan, matching `Discovery`'s `.gwtignore` convention so
+// the domain tree and the test tree exclude the same generated/vendored trees.
+let gwtIgnoreFile = ".gwtignore"
+let isPruned = (entries: array<dirent>) => entries->Array.some(e => e.name == gwtIgnoreFile)
+
+// Source `.res` only — `.res.mjs` / `.res.js` end in `.mjs` / `.js`, and `.resi`
+// in `.resi`, so a plain `.res` suffix test excludes compiled output + interfaces.
+let isSrcResFile = (name: string) => String.endsWith(name, ".res")
+
+let rec walk = async (dir: string, acc: array<string>): array<string> => {
+  let entries = try {
+    await _readdir(dir, {withFileTypes: true})
+  } catch {
+  | _ => []
+  }
+  if isPruned(entries) {
+    acc
+  } else {
+  let found = ref(acc)
+  for i in 0 to entries->Array.length - 1 {
+    let entry = entries->Array.getUnsafe(i)
+    if !shouldIgnore(entry.name) {
+      let full = join(dir, entry.name)
+      if entry._isDirectory() {
+        let nested = await walk(full, [])
+        found := Array.concat(found.contents, nested)
+      } else if entry._isFile() && isSrcResFile(entry.name) {
+        found := Array.concat(found.contents, [full])
+      }
+    }
+  }
+  found.contents
+  }
+}
+
+// Enumerate components across the given package directories (deduplicated per
+// dir+kind+name, declaration order preserved). Each component accumulates the
+// source files that map to it (spec + body files).
+type orderEntry = {dir: string, kind: string, name: string, key: string}
+
+let scan = async (pkgDirs: array<string>): array<component> => {
+  let order = []
+  let filesByKey = Dict.make()
+  for i in 0 to pkgDirs->Array.length - 1 {
+    let dir = pkgDirs->Array.getUnsafe(i)
+    let srcDir = join(dir, "src")
+    if _existsSync(srcDir) {
+      let files = await walk(srcDir, [])
+      files->Array.forEach(file =>
+        switch ComponentMeta.componentOfSrcFile(file) {
+        | Some(c) =>
+          let key = dir ++ "::" ++ c.kind ++ "::" ++ c.name
+          switch filesByKey->Dict.get(key) {
+          | Some(existing) => filesByKey->Dict.set(key, Array.concat(existing, [file]))
+          | None => {
+              filesByKey->Dict.set(key, [file])
+              order->Array.push({dir, kind: c.kind, name: c.name, key})
+            }
+          }
+        | None => ()
+        }
+      )
+    }
+  }
+  order->Array.map(o => {
+    dir: o.dir,
+    kind: o.kind,
+    name: o.name,
+    files: filesByKey->Dict.get(o.key)->Option.getOr([]),
+  })
+}