cleanup

4 files changed, 0 insertions, 360 deletions

diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/discover.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/erlang/discover.gleam
deleted file mode 100644
index ecb752d..0000000
--- a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/discover.gleam
+++ /dev/null
@@ -1,167 +0,0 @@
-@target(erlang)
-import gleam/io
-@target(erlang)
-import gleam/dynamic.{type Dynamic}
-@target(erlang)
-import gleam/list
-@target(erlang)
-import gleam/string
-@target(erlang)
-import gleam/int
-@target(erlang)
-import gleam/option.{type Option, None, Some}
-@target(erlang)
-import gleam/erlang/atom.{type Atom}
-@target(erlang)
-import showtime/internal/common/test_suite.{
-  type TestModule, type TestModuleHandler, type TestSuite, TestFunction,
-  TestModule, TestSuite,
-}
-import simplifile
-
-// Module collector for erlang
-// Will search the test folder for files ending with _test and notify
-// the module handler about each module it finds
-@target(erlang)
-pub fn collect_modules(
-  test_module_handler: TestModuleHandler,
-  only_modules: Option(List(String)),
-) -> List(TestModule) {
-  collect_modules_in_folder("./test", test_module_handler, only_modules)
-}
-
-@target(erlang)
-fn collect_modules_in_folder(
-  path: String,
-  test_module_handler: TestModuleHandler,
-  only_modules: Option(List(String)),
-) {
-  let module_prefix = get_module_prefix(path)
-  let assert Ok(files) = simplifile.read_directory(path)
-  let test_modules_in_folder =
-    files
-    |> list.filter(string.ends_with(_, "_test.gleam"))
-    |> list.filter_map(fn(test_module_file) {
-      let module_name =
-        module_prefix <> {
-          test_module_file
-          |> string.replace(".gleam", "")
-        }
-      case only_modules {
-        Some(only_modules_list) -> {
-          let module_in_list =
-            only_modules_list
-            |> list.any(fn(only_module_name) {
-              only_module_name == module_name
-              |> string.replace("@", "/")
-            })
-          case module_in_list {
-            True -> {
-              let test_module = TestModule(module_name, Some(test_module_file))
-              test_module_handler(test_module)
-              Ok(test_module)
-            }
-
-            False -> Error(Nil)
-          }
-        }
-        None -> {
-          let test_module = TestModule(module_name, Some(test_module_file))
-          test_module_handler(test_module)
-          Ok(test_module)
-        }
-      }
-    })
-  let test_modules_in_subfolders =
-    files
-    |> list.map(fn(filename) { path <> "/" <> filename })
-    |> list.filter(fn(file) { simplifile.is_directory(file) })
-    |> list.fold(
-      [],
-      fn(modules, subfolder) {
-        modules
-        |> list.append(collect_modules_in_folder(
-          subfolder,
-          test_module_handler,
-          only_modules,
-        ))
-      },
-    )
-  test_modules_in_folder
-  |> list.append(test_modules_in_subfolders)
-}
-
-@target(erlang)
-fn get_module_prefix(path) {
-  let path_without_test =
-    path
-    |> string.replace("./test", "")
-
-  let path_without_leading_slash = case
-    string.starts_with(path_without_test, "/")
-  {
-    True -> string.drop_left(path_without_test, 1)
-    False -> path_without_test
-  }
-  let module_prefix =
-    path_without_leading_slash
-    |> string.replace("/", "@")
-  case string.length(module_prefix) {
-    0 -> module_prefix
-    _ -> module_prefix <> "@"
-  }
-}
-
-// Test function collector for erlang
-// Uses erlang `apply` to run `module_info` for the test module
-// and collects all the exports ending with _test into a `TestSuite`
-@target(erlang)
-pub fn collect_test_functions(module: TestModule) -> TestSuite {
-  let test_functions: List(#(Atom, Int)) =
-    apply(
-      atom.create_from_string(module.name),
-      atom.create_from_string("module_info"),
-      [dynamic.from(atom.create_from_string("exports"))],
-    )
-    |> dynamic.unsafe_coerce()
-
-  let test_functions_filtered =
-    test_functions
-    |> list.map(fn(entry) {
-      let assert #(name, arity) = entry
-      #(
-        name
-        |> atom.to_string(),
-        arity,
-      )
-    })
-    |> list.filter_map(fn(entry) {
-      let assert #(name, arity) = entry
-      case string.ends_with(name, "_test") {
-        True ->
-          case arity {
-            0 -> Ok(name)
-            _ -> {
-              io.println(
-                "WARNING: function \"" <> name <> "\" has arity: " <> int.to_string(
-                  arity,
-                ) <> " - cannot be used as test (needs to be 0)",
-              )
-              Error("Wrong arity")
-            }
-          }
-        False -> Error("Non matching name")
-      }
-    })
-    |> list.filter(string.ends_with(_, "_test"))
-    |> list.map(fn(function_name) { TestFunction(function_name) })
-  TestSuite(module, test_functions_filtered)
-}
-
-@target(erlang)
-@external(erlang, "erlang", "apply")
-fn apply(
-  module module: Atom,
-  function function: Atom,
-  args args: List(Dynamic),
-) -> Dynamic
diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/event_handler.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/erlang/event_handler.gleam
deleted file mode 100644
index 62a9caf..0000000
--- a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/event_handler.gleam
+++ /dev/null
@@ -1,91 +0,0 @@
-@target(erlang)
-import gleam/io
-@target(erlang)
-import gleam/otp/actor.{Continue, Stop}
-@target(erlang)
-import gleam/erlang/process.{type Subject, Normal}
-@target(erlang)
-import gleam/map
-@target(erlang)
-import showtime/internal/common/test_suite.{type TestEvent, EndTestRun}
-@target(erlang)
-import showtime/internal/common/common_event_handler.{
-  Finished, HandlerState, NotStarted, handle_event,
-}
-@target(erlang)
-import showtime/internal/reports/formatter.{create_test_report}
-@target(erlang)
-import gleam/erlang.{Millisecond}
-@target(erlang)
-import gleam/option.{None}
-
-@target(erlang)
-type EventHandlerMessage {
-  EventHandlerMessage(test_event: TestEvent, reply_to: Subject(Int))
-}
-
-// Starts an actor that receives test events and forwards the to the event handler
-// When handler updates the state to `Finished` the actor will wait until handler
-// reports that all modules are done and the stop
-@target(erlang)
-pub fn start() {
-  let assert Ok(subject) =
-    actor.start(
-      #(NotStarted, 0, map.new()),
-      fn(msg: EventHandlerMessage, state) {
-        let EventHandlerMessage(test_event, reply_to) = msg
-        let #(test_state, num_done, events) = state
-        let updated_state =
-          handle_event(
-            test_event,
-            system_time,
-            HandlerState(test_state, num_done, events),
-          )
-        case updated_state {
-          HandlerState(Finished(num_modules), num_done, events) if num_done == num_modules -> {
-            let #(test_report, num_failed) = create_test_report(events)
-            io.println(test_report)
-            process.send(reply_to, num_failed)
-            Stop(Normal)
-          }
-          HandlerState(test_state, num_done, events) ->
-            Continue(#(test_state, num_done, events), None)
-        }
-      },
-    )
-  let parent_subject = process.new_subject()
-
-  let selector =
-    process.new_selector()
-    |> process.selecting(parent_subject, fn(x) { x })
-
-  // Returns a callback that can receive test events
-  fn(test_event: TestEvent) {
-    case test_event {
-      EndTestRun(..) -> {
-        // When EndTestRun has been received the callback will wait until the
-        // actor has stopped
-        // TODO: Use a timeout?
-        process.send(subject, EventHandlerMessage(test_event, parent_subject))
-        let num_failed = process.select_forever(selector)
-        case num_failed > 0 {
-          True -> halt(1)
-          False -> halt(0)
-        }
-      }
-
-      // Normally just send the test event to the actor
-      _ ->
-        process.send(subject, EventHandlerMessage(test_event, parent_subject))
-    }
-  }
-}
-
-@target(erlang)
-@external(erlang, "erlang", "halt")
-fn halt(a: Int) -> Nil
-
-@target(erlang)
-fn system_time() {
-  erlang.system_time(Millisecond)
-}
diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/module_handler.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/erlang/module_handler.gleam
deleted file mode 100644
index 88cc251..0000000
--- a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/module_handler.gleam
+++ /dev/null
@@ -1,43 +0,0 @@
-@target(erlang)
-import gleam/otp/actor.{Continue}
-@target(erlang)
-import gleam/erlang/process
-@target(erlang)
-import showtime/internal/common/test_suite.{
-  type TestEventHandler, type TestFunctionCollector, type TestModule,
-  type TestRunner, EndTestSuite, StartTestSuite,
-}
-@target(erlang)
-import showtime/internal/common/cli.{type Capture}
-@target(erlang)
-import gleam/option.{None}
-
-@target(erlang)
-pub fn start(
-  test_event_handler: TestEventHandler,
-  test_function_collector: TestFunctionCollector,
-  run_test_suite: TestRunner,
-  ignore_tags: List(String),
-  capture: Capture,
-) {
-  let assert Ok(subject) =
-    actor.start(
-      Nil,
-      fn(module: TestModule, state) {
-        process.start(
-          fn() {
-            let test_suite = test_function_collector(module)
-            test_event_handler(StartTestSuite(module))
-            run_test_suite(test_suite, test_event_handler, ignore_tags, capture)
-            test_event_handler(EndTestSuite(module))
-          },
-          False,
-        )
-        Continue(state, None)
-      },
-    )
-  fn(test_module: TestModule) {
-    process.send(subject, test_module)
-    Nil
-  }
-}
diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/runner.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/erlang/runner.gleam
deleted file mode 100644
index ebbf426..0000000
--- a/aoc2023/build/packages/adglent/src/showtime/internal/erlang/runner.gleam
+++ /dev/null
@@ -1,59 +0,0 @@
-@target(erlang)
-import gleam/list
-@target(erlang)
-import gleam/erlang/atom.{type Atom}
-@target(erlang)
-import showtime/internal/common/test_suite.{
-  type TestEventHandler, type TestSuite, EndTest, StartTest,
-}
-@target(erlang)
-import showtime/internal/common/test_result.{type TestResult}
-@target(erlang)
-import showtime/internal/common/cli.{type Capture}
-
-// Runs all tests in a test suite
-@target(erlang)
-pub fn run_test_suite(
-  test_suite: TestSuite,
-  test_event_handler: TestEventHandler,
-  ignore_tags: List(String),
-  capture: Capture,
-) {
-  test_suite.tests
-  |> list.each(fn(test) {
-    test_event_handler(StartTest(test_suite.module, test))
-    let result =
-      run_test(test_suite.module.name, test.name, ignore_tags, capture)
-    test_event_handler(EndTest(test_suite.module, test, result))
-  })
-}
-
-// Wrapper around the ffi function that converts names to atoms
-@target(erlang)
-pub fn run_test(
-  module_name: String,
-  test_name: String,
-  ignore_tags: List(String),
-  capture: Capture,
-) -> TestResult {
-  let result =
-    run_test_ffi(
-      atom.create_from_string(module_name),
-      atom.create_from_string(test_name),
-      ignore_tags,
-      capture,
-    )
-  result
-}
-
-// Calls ffi for running a test function
-// The ffi will take care of mapping the result and exception to the data-types
-// used in gleam
-@target(erlang)
-@external(erlang, "showtime_ffi", "run_test")
-fn run_test_ffi(
-  module module: Atom,
-  function function: Atom,
-  ignore_tags ignore_tags: List(String),
-  capture capture: Capture,
-) -> TestResult