Update vendored gleeunit

Author: lpil

test/eunit_progress.erl

@@ -1,3 +1,5 @@
-@external(erlang, "gleam_stdlib_test_ffi", "main")
-@external(javascript, "././gleeunit.mjs", "main")
-pub fn main() -> Nil
+import gleeunit
+
+pub fn main() -> Nil {
+  gleeunit.main()
+}

test/gleam_stdlib_test.gleam

@@ -0,0 +1,70 @@
+import gleam/list
+import gleam/string
+
+/// Find and run all test functions for the current project using Erlang's EUnit
+/// test framework, or a custom JavaScript test runner.
+///
+/// Any Erlang or Gleam function in the `test` directory with a name ending in
+/// `_test` is considered a test function and will be run.
+///
+/// A test that panics is considered a failure.
+///
+pub fn main() -> Nil {
+  do_main()
+}
+
+@external(javascript, "./gleeunit_ffi.mjs", "main")
+fn do_main() -> Nil {
+  let options = [Verbose, NoTty, Report(#(GleeunitProgress, [Colored(True)]))]
+
+  let result =
+    find_files(matching: "**/*.{erl,gleam}", in: "test")
+    |> list.map(gleam_to_erlang_module_name)
+    |> list.map(dangerously_convert_string_to_atom(_, Utf8))
+    |> run_eunit(options)
+
+  let code = case result {
+    Ok(_) -> 0
+    Error(_) -> 1
+  }
+  halt(code)
+}
+
+@external(erlang, "erlang", "halt")
+fn halt(a: Int) -> Nil
+
+fn gleam_to_erlang_module_name(path: String) -> String {
+  path
+  |> string.replace(".gleam", "")
+  |> string.replace(".erl", "")
+  |> string.replace("/", "@")
+}
+
+@external(erlang, "gleeunit_ffi", "find_files")
+fn find_files(matching matching: String, in in: String) -> List(String)
+
+type Atom
+
+type Encoding {
+  Utf8
+}
+
+@external(erlang, "erlang", "binary_to_atom")
+fn dangerously_convert_string_to_atom(a: String, b: Encoding) -> Atom
+
+type ReportModuleName {
+  GleeunitProgress
+}
+
+type GleeunitProgressOption {
+  Colored(Bool)
+}
+
+type EunitOption {
+  Verbose
+  NoTty
+  Report(#(ReportModuleName, List(GleeunitProgressOption)))
+}
+
+@external(erlang, "gleeunit_ffi", "run_eunit")
+fn run_eunit(a: List(Atom), b: List(EunitOption)) -> Result(Nil, a)

test/gleeunit.gleam

@@ -0,0 +1,49 @@
+import gleam/dynamic
+
+pub type GleamPanic {
+  GleamPanic(
+    message: String,
+    file: String,
+    module: String,
+    function: String,
+    line: Int,
+    kind: PanicKind,
+  )
+}
+
+pub type PanicKind {
+  Todo
+  Panic
+  LetAssert(
+    start: Int,
+    end: Int,
+    pattern_start: Int,
+    pattern_end: Int,
+    value: dynamic.Dynamic,
+  )
+  Assert(start: Int, end: Int, expression_start: Int, kind: AssertKind)
+}
+
+pub type AssertKind {
+  BinaryOperator(
+    operator: String,
+    left: AssertedExpression,
+    right: AssertedExpression,
+  )
+  FunctionCall(arguments: List(AssertedExpression))
+  OtherExpression(expression: AssertedExpression)
+}
+
+pub type AssertedExpression {
+  AssertedExpression(start: Int, end: Int, kind: ExpressionKind)
+}
+
+pub type ExpressionKind {
+  Literal(value: dynamic.Dynamic)
+  Expression(value: dynamic.Dynamic)
+  Unevaluated
+}
+
+@external(erlang, "gleeunit_gleam_panic_ffi", "from_dynamic")
+@external(javascript, "./gleeunit_gleam_panic_ffi.mjs", "from_dynamic")
+pub fn from_dynamic(data: dynamic.Dynamic) -> Result(GleamPanic, Nil)

test/gleeunit.mjs

@@ -0,0 +1,49 @@
+-module(gleeunit_gleam_panic_ffi).
+-export([from_dynamic/1]).
+
+from_dynamic(#{
+  gleam_error := assert,
+  start := Start,
+  'end' := End,
+  expression_start := EStart
+} = E) ->
+    wrap(E, {assert, Start, End, EStart, assert_kind(E)});
+from_dynamic(#{
+  gleam_error := let_assert,
+  start := Start,
+  'end' := End,
+  pattern_start := PStart,
+  pattern_end := PEnd,
+  value := Value
+} = E) ->
+    wrap(E, {let_assert, Start, End, PStart, PEnd, Value});
+from_dynamic(#{gleam_error := panic} = E) ->
+    wrap(E, panic);
+from_dynamic(#{gleam_error := todo} = E) ->
+    wrap(E, todo);
+from_dynamic(_) ->
+    {error, nil}.
+
+assert_kind(#{kind := binary_operator, left := L, right := R, operator := O}) ->
+    {binary_operator, atom_to_binary(O), expression(L), expression(R)};
+assert_kind(#{kind := function_call, arguments := Arguments}) ->
+    {function_call, lists:map(fun expression/1, Arguments)};
+assert_kind(#{kind := expression, expression := Expression}) ->
+    {other_expression, expression(Expression)}.
+
+expression(#{start := S, 'end' := E, kind := literal, value := Value}) ->
+    {asserted_expression, S, E, {literal, Value}};
+expression(#{start := S, 'end' := E, kind := expression, value := Value}) ->
+    {asserted_expression, S, E, {expression, Value}};
+expression(#{start := S, 'end' := E, kind := unevaluated}) ->
+    {asserted_expression, S, E, unevaluated}.
+
+wrap(#{
+    gleam_error := _,
+    file := File,
+    message := Message,
+    module := Module,
+    function := Function,
+    line := Line
+}, Kind) ->
+    {ok, {gleam_panic, Message, File, Module, Function, Line, Kind}}.

test/gleeunit/internal/gleam_panic.gleam

@@ -0,0 +1,91 @@
+import { Ok, Error, Empty, NonEmpty } from "../../gleam.mjs";
+import {
+  GleamPanic,
+  Todo,
+  Panic,
+  LetAssert,
+  Assert,
+  BinaryOperator,
+  FunctionCall,
+  OtherExpression,
+  AssertedExpression,
+  Literal,
+  Expression,
+  Unevaluated,
+} from "./gleam_panic.mjs";
+
+export function from_dynamic(error) {
+  if (!(error instanceof globalThis.Error) || !error.gleam_error) {
+    return new Error(undefined);
+  }
+
+  if (error.gleam_error === "todo") {
+    return wrap(error, new Todo());
+  }
+
+  if (error.gleam_error === "panic") {
+    return wrap(error, new Panic());
+  }
+
+  if (error.gleam_error === "let_assert") {
+    let kind = new LetAssert(
+      error.start,
+      error.end,
+      error.pattern_start,
+      error.pattern_end,
+      error.value,
+    );
+    return wrap(error, kind);
+  }
+
+  if (error.gleam_error === "assert") {
+    let kind = new Assert(
+      error.start,
+      error.end,
+      error.expression_start,
+      assert_kind(error),
+    );
+    return wrap(error, kind);
+  }
+
+  return new Error(undefined);
+}
+
+function assert_kind(error) {
+  if (error.kind == "binary_operator") {
+    return new BinaryOperator(
+      error.operator,
+      expression(error.left),
+      expression(error.right),
+    );
+  }
+
+  if (error.kind == "function_call") {
+    let list = new Empty();
+    let i = error.arguments.length;
+    while (i--) {
+      list = new NonEmpty(expression(error.arguments[i]), list);
+    }
+    return new FunctionCall(list);
+  }
+
+  return new OtherExpression(expression(error.expression));
+}
+
+function expression(data) {
+  const expression = new AssertedExpression(data.start, data.end, undefined);
+  if (data.kind == "literal") {
+    expression.kind = new Literal(data.value);
+  } else if (data.kind == "expression") {
+    expression.kind = new Expression(data.value);
+  } else {
+    expression.kind = new Unevaluated();
+  }
+  return expression;
+}
+
+function wrap(e, kind) {
+  return new Ok(
+    new GleamPanic(e.message, e.file, e.module, e.function, e.line, kind),
+  );
+}