Use new JavaScript API

.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: erlef/setup-beam@v1
         with:
           otp-version: "28"
-          gleam-version: "1.11.0-rc2"
+          gleam-version: "1.13.0"
       - uses: denoland/setup-deno@v1
         with:
           deno-version: v1.x

gleam.toml

@@ -4,7 +4,7 @@ licences = ["Apache-2.0"]
 description = "A simple test runner for Gleam, using EUnit on Erlang"
 repository = { type = "github", user = "lpil", repo = "gleeunit" }
 links = [{ title = "Sponsor", href = "https://github.com/sponsors/lpil" }]
-gleam = ">= 1.11.0"
+gleam = ">= 1.13.0"
 
 [javascript.deno]
 allow_read = ["gleam.toml", "test", "build"]

src/gleeunit/internal/gleeunit_gleam_panic_ffi.mjs

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

src/gleeunit/should.gleam

@@ -8,11 +8,11 @@ pub fn equal(a: t, b: t) -> Nil {
     True -> Nil
     _ ->
       panic as string.concat([
-        "\n",
-        string.inspect(a),
-        "\nshould equal\n",
-        string.inspect(b),
-      ])
+          "\n",
+          string.inspect(a),
+          "\nshould equal\n",
+          string.inspect(b),
+        ])
   }
 }
 
@@ -21,11 +21,11 @@ pub fn not_equal(a: t, b: t) -> Nil {
     True -> Nil
     _ ->
       panic as string.concat([
-        "\n",
-        string.inspect(a),
-        "\nshould not equal\n",
-        string.inspect(b),
-      ])
+          "\n",
+          string.inspect(a),
+          "\nshould not equal\n",
+          string.inspect(b),
+        ])
   }
 }
 

src/gleeunit_ffi.mjs

@@ -1,12 +1,12 @@
 import { readFileSync } from "node:fs";
-import { Ok, Error as GleamError } from "./gleam.mjs";
+import { Result$Ok, Result$Error } from "./gleam.mjs";
 import * as reporting from "./gleeunit/internal/reporting.mjs";
 
 export function read_file(path) {
   try {
-    return new Ok(readFileSync(path));
+    return Result$Ok(readFileSync(path));
   } catch {
-    return new GleamError(undefined);
+    return Result$Error(undefined);
   }
 }