@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/src/Collector.res

@@ -0,0 +1,201 @@
+// 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>,
+}
+
+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
+  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=?,
+  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,
+  }
+  entries := Array.concat(entries.contents, [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,
+  }
+  entries := Array.concat(entries.contents, [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,215 @@
+// 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;
+  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, 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
+  };
+  entries.contents = entries.contents.concat([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
+  };
+  entries.contents = entries.contents.concat([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,104 @@
+// 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}
+
+// Folder names that denote a component kind. A file counts as a component when
+// its immediate parent folder is one of these.
+let kindFolders = [
+  "Aggregate",
+  "StateChangeSlice",
+  "StateViewSlice",
+  "StateViewSliceStream",
+  "ReadModel",
+  "ReadModelStream",
+  "AutomationSlice",
+  "InboundTranslationSlice",
+  "OutboundTranslationSlice",
+  "Extension",
+  "ExtensionPoint",
+  "Task",
+]
+
+let isKindFolder = (segment: string) => kindFolders->Array.includes(segment)
+
+// Body-file suffixes stripped to recover the spec stem (longest first so
+// `_ExtensionPointMapping` is removed before `_ExtensionPoint`). Spec and body
+// files in one folder collapse to the same component name.
+let bodySuffixes = [
+  "_ExtensionPointMapping",
+  "_ExtensionPoint",
+  "_Extension",
+  "_Projections",
+  "_Projection",
+  "_Mappings",
+  "_Behavior",
+  "_Automation",
+  "_Translation",
+]
+
+let stripBody = (stem: string) =>
+  switch 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.
+let componentOfTestFile = (path: string): option<component> =>
+  switch parentFolder(path) {
+  | Some(folder) if isKindFolder(folder) =>
+    Some({kind: folder, name: path->basename->stem->stripGwt->stripBody})
+  | _ => None
+  }
+
+// {kind, name} for a src/ component file (spec or body), or None.
+let componentOfSrcFile = (path: string): option<component> =>
+  switch parentFolder(path) {
+  | Some(folder) if isKindFolder(folder) =>
+    Some({kind: folder, name: path->basename->stem->stripBody})
+  | _ => None
+  }

package/src/ComponentMeta.res.mjs

@@ -0,0 +1,120 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+let kindFolders = [
+  "Aggregate",
+  "StateChangeSlice",
+  "StateViewSlice",
+  "StateViewSliceStream",
+  "ReadModel",
+  "ReadModelStream",
+  "AutomationSlice",
+  "InboundTranslationSlice",
+  "OutboundTranslationSlice",
+  "Extension",
+  "ExtensionPoint",
+  "Task"
+];
+
+function isKindFolder(segment) {
+  return kindFolders.includes(segment);
+}
+
+let bodySuffixes = [
+  "_ExtensionPointMapping",
+  "_ExtensionPoint",
+  "_Extension",
+  "_Projections",
+  "_Projection",
+  "_Mappings",
+  "_Behavior",
+  "_Automation",
+  "_Translation"
+];
+
+function stripBody(stem) {
+  let suf = 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 folder = parentFolder(path);
+  if (folder !== undefined && kindFolders.includes(folder)) {
+    return {
+      kind: folder,
+      name: stripBody(stripGwt(stem(basename(path))))
+    };
+  }
+}
+
+function componentOfSrcFile(path) {
+  let folder = parentFolder(path);
+  if (folder !== undefined && kindFolders.includes(folder)) {
+    return {
+      kind: folder,
+      name: stripBody(stem(basename(path)))
+    };
+  }
+}
+
+export {
+  kindFolders,
+  isKindFolder,
+  bodySuffixes,
+  stripBody,
+  stripGwt,
+  basename,
+  parentFolder,
+  stem,
+  componentOfTestFile,
+  componentOfSrcFile,
+}
+/* No side effect */