skill-universe 1.1.0

package/build/dev/javascript/gleeunit/gleeunit@should.erl

@@ -0,0 +1,153 @@
+-module(gleeunit@should).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/gleeunit/should.gleam").
+-export([equal/2, not_equal/2, be_ok/1, be_error/1, be_some/1, be_none/1, be_true/1, be_false/1, fail/0]).
+
+-if(?OTP_RELEASE >= 27).
+-define(MODULEDOC(Str), -moduledoc(Str)).
+-define(DOC(Str), -doc(Str)).
+-else.
+-define(MODULEDOC(Str), -compile([])).
+-define(DOC(Str), -compile([])).
+-endif.
+
+?MODULEDOC(" Use the `assert` keyword instead of this module.\n").
+
+-file("src/gleeunit/should.gleam", 6).
+-spec equal(DOF, DOF) -> nil.
+equal(A, B) ->
+    case A =:= B of
+        true ->
+            nil;
+
+        _ ->
+            erlang:error(#{gleam_error => panic,
+                    message => erlang:list_to_binary(
+                        [<<"\n"/utf8>>,
+                            gleam@string:inspect(A),
+                            <<"\nshould equal\n"/utf8>>,
+                            gleam@string:inspect(B)]
+                    ),
+                    file => <<?FILEPATH/utf8>>,
+                    module => <<"gleeunit/should"/utf8>>,
+                    function => <<"equal"/utf8>>,
+                    line => 10})
+    end.
+
+-file("src/gleeunit/should.gleam", 19).
+-spec not_equal(DOG, DOG) -> nil.
+not_equal(A, B) ->
+    case A /= B of
+        true ->
+            nil;
+
+        _ ->
+            erlang:error(#{gleam_error => panic,
+                    message => erlang:list_to_binary(
+                        [<<"\n"/utf8>>,
+                            gleam@string:inspect(A),
+                            <<"\nshould not equal\n"/utf8>>,
+                            gleam@string:inspect(B)]
+                    ),
+                    file => <<?FILEPATH/utf8>>,
+                    module => <<"gleeunit/should"/utf8>>,
+                    function => <<"not_equal"/utf8>>,
+                    line => 23})
+    end.
+
+-file("src/gleeunit/should.gleam", 32).
+-spec be_ok({ok, DOH} | {error, any()}) -> DOH.
+be_ok(A) ->
+    case A of
+        {ok, Value} ->
+            Value;
+
+        _ ->
+            erlang:error(#{gleam_error => panic,
+                    message => erlang:list_to_binary(
+                        [<<"\n"/utf8>>,
+                            gleam@string:inspect(A),
+                            <<"\nshould be ok"/utf8>>]
+                    ),
+                    file => <<?FILEPATH/utf8>>,
+                    module => <<"gleeunit/should"/utf8>>,
+                    function => <<"be_ok"/utf8>>,
+                    line => 35})
+    end.
+
+-file("src/gleeunit/should.gleam", 39).
+-spec be_error({ok, any()} | {error, DOM}) -> DOM.
+be_error(A) ->
+    case A of
+        {error, Error} ->
+            Error;
+
+        _ ->
+            erlang:error(#{gleam_error => panic,
+                    message => erlang:list_to_binary(
+                        [<<"\n"/utf8>>,
+                            gleam@string:inspect(A),
+                            <<"\nshould be error"/utf8>>]
+                    ),
+                    file => <<?FILEPATH/utf8>>,
+                    module => <<"gleeunit/should"/utf8>>,
+                    function => <<"be_error"/utf8>>,
+                    line => 42})
+    end.
+
+-file("src/gleeunit/should.gleam", 46).
+-spec be_some(gleam@option:option(DOP)) -> DOP.
+be_some(A) ->
+    case A of
+        {some, Value} ->
+            Value;
+
+        _ ->
+            erlang:error(#{gleam_error => panic,
+                    message => erlang:list_to_binary(
+                        [<<"\n"/utf8>>,
+                            gleam@string:inspect(A),
+                            <<"\nshould be some"/utf8>>]
+                    ),
+                    file => <<?FILEPATH/utf8>>,
+                    module => <<"gleeunit/should"/utf8>>,
+                    function => <<"be_some"/utf8>>,
+                    line => 49})
+    end.
+
+-file("src/gleeunit/should.gleam", 53).
+-spec be_none(gleam@option:option(any())) -> nil.
+be_none(A) ->
+    case A of
+        none ->
+            nil;
+
+        _ ->
+            erlang:error(#{gleam_error => panic,
+                    message => erlang:list_to_binary(
+                        [<<"\n"/utf8>>,
+                            gleam@string:inspect(A),
+                            <<"\nshould be none"/utf8>>]
+                    ),
+                    file => <<?FILEPATH/utf8>>,
+                    module => <<"gleeunit/should"/utf8>>,
+                    function => <<"be_none"/utf8>>,
+                    line => 56})
+    end.
+
+-file("src/gleeunit/should.gleam", 60).
+-spec be_true(boolean()) -> nil.
+be_true(Actual) ->
+    _pipe = Actual,
+    equal(_pipe, true).
+
+-file("src/gleeunit/should.gleam", 65).
+-spec be_false(boolean()) -> nil.
+be_false(Actual) ->
+    _pipe = Actual,
+    equal(_pipe, false).
+
+-file("src/gleeunit/should.gleam", 70).
+-spec fail() -> nil.
+fail() ->
+    be_true(false).

package/build/dev/javascript/gleeunit/gleeunit_ffi.erl

@@ -0,0 +1,21 @@
+-module(gleeunit_ffi).
+
+-export([find_files/2, run_eunit/2]).
+
+find_files(Pattern, In) ->
+  Results = filelib:wildcard(binary_to_list(Pattern), binary_to_list(In)),
+  lists:map(fun list_to_binary/1, Results).
+
+run_eunit(Tests, Options) ->
+    case code:which(eunit) of
+        non_existing ->
+            gleeunit@internal@reporting:eunit_missing();
+
+        _ -> 
+            case eunit:test(Tests, Options) of
+                ok -> {ok, nil};
+                error -> {error, nil};
+                {error, Term} -> {error, Term}
+            end
+    end.
+    

package/build/dev/javascript/gleeunit/gleeunit_ffi.mjs

@@ -0,0 +1,100 @@
+import { readFileSync } from "node:fs";
+import { Result$Ok, Result$Error } from "./gleam.mjs";
+import * as reporting from "./gleeunit/internal/reporting.mjs";
+
+export function read_file(path) {
+  try {
+    return Result$Ok(readFileSync(path));
+  } catch {
+    return Result$Error(undefined);
+  }
+}
+
+async function* gleamFiles(directory) {
+  for (let entry of await read_dir(directory)) {
+    let path = join_path(directory, entry);
+    if (path.endsWith(".gleam")) {
+      yield path;
+    } else {
+      try {
+        yield* gleamFiles(path);
+      } catch (error) {
+        // Could not read directory, assume it's a file
+      }
+    }
+  }
+}
+
+async function readRootPackageName() {
+  let toml = await async_read_file("gleam.toml", "utf-8");
+  for (let line of toml.split("\n")) {
+    let matches = line.match(/\s*name\s*=\s*"([a-z][a-z0-9_]*)"/); // Match regexp in compiler-cli/src/new.rs in validate_name()
+    if (matches) return matches[1];
+  }
+  throw new Error("Could not determine package name from gleam.toml");
+}
+
+export async function main() {
+  let state = reporting.new_state();
+
+  let packageName = await readRootPackageName();
+  let dist = `../${packageName}/`;
+
+  for await (let path of await gleamFiles("test")) {
+    let js_path = path.slice("test/".length).replace(".gleam", ".mjs");
+    let module = await import(join_path(dist, js_path));
+    for (let fnName of Object.keys(module)) {
+      if (!fnName.endsWith("_test")) continue;
+      try {
+        await module[fnName]();
+        state = reporting.test_passed(state);
+      } catch (error) {
+        let moduleName = js_path.slice(0, -4);
+        state = reporting.test_failed(state, moduleName, fnName, error);
+      }
+    }
+  }
+
+  const status = reporting.finished(state);
+  exit(status);
+}
+
+export function crash(message) {
+  throw new Error(message);
+}
+
+function exit(code) {
+  if (globalThis.Deno) {
+    Deno.exit(code);
+  } else {
+    process.exit(code);
+  }
+}
+
+async function read_dir(path) {
+  if (globalThis.Deno) {
+    let items = [];
+    for await (let item of Deno.readDir(path, { withFileTypes: true })) {
+      items.push(item.name);
+    }
+    return items;
+  } else {
+    let { readdir } = await import("node:fs/promises");
+    return readdir(path);
+  }
+}
+
+function join_path(a, b) {
+  if (a.endsWith("/")) return a + b;
+  return a + "/" + b;
+}
+
+async function async_read_file(path) {
+  if (globalThis.Deno) {
+    return Deno.readTextFile(path);
+  } else {
+    let { readFile } = await import("node:fs/promises");
+    let contents = await readFile(path);
+    return contents.toString();
+  }
+}

package/build/dev/javascript/gleeunit/gleeunit_progress.erl

@@ -0,0 +1,72 @@
+%% A formatter adapted from Sean Cribb's https://github.com/seancribbs/eunit_formatters
+
+-module(gleeunit_progress).
+-define(NOTEST, true).
+
+%% eunit_listener callbacks
+-export([
+    init/1, handle_begin/3, handle_end/3, handle_cancel/3, terminate/2,
+    start/0, start/1
+]).
+
+-define(reporting, gleeunit@internal@reporting).
+
+start() ->
+    start([]).
+
+start(Options) ->
+    eunit_listener:start(?MODULE, Options).
+
+init(_Options) ->
+    ?reporting:new_state().
+
+handle_begin(_test_or_group, _data, State) ->
+    State.
+
+handle_end(group, _data, State) ->
+    State;
+handle_end(test, Data, State) ->
+    {AtomModule, AtomFunction, _Arity} = proplists:get_value(source, Data),
+    Module = erlang:atom_to_binary(AtomModule),
+    Function = erlang:atom_to_binary(AtomFunction),
+
+    % EUnit swallows stdout, so print it to make debugging easier.
+    case proplists:get_value(output, Data) of
+        undefined -> ok;
+        <<>> -> ok;
+        Out -> gleam@io:print(Out)
+    end,
+
+    case proplists:get_value(status, Data) of
+        ok ->
+            ?reporting:test_passed(State);
+        {skipped, _Reason} ->
+            ?reporting:test_skipped(State, Module, Function);
+        {error, {_, Exception, _Stack}} ->
+            ?reporting:test_failed(State, Module, Function, Exception)
+    end.
+
+
+handle_cancel(_test_or_group, Data, State) ->
+    ?reporting:test_failed(State, <<"gleeunit">>, <<"main">>, Data).
+
+terminate({ok, _Data}, State) ->
+    ?reporting:finished(State),
+    ok;
+terminate({error, Reason}, State) ->
+    ?reporting:finished(State),
+    io:fwrite("
+Eunit failed:
+
+~80p
+
+This is probably a bug in gleeunit. Please report it.
+", [Reason]),
+    sync_end(error).
+
+sync_end(Result) ->
+    receive
+        {stop, Reference, ReplyTo} ->
+            ReplyTo ! {result, Reference, Result},
+            ok
+    end.