diff options
Diffstat (limited to 'aoc2023/build/packages/adglent/src/showtime')
15 files changed, 0 insertions, 1575 deletions
diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/common/cli.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/common/cli.gleam deleted file mode 100644 index 1c03211..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/common/cli.gleam +++ /dev/null @@ -1,5 +0,0 @@ -pub type Capture { - Yes - No - Mixed -} diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/common/common_event_handler.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/common/common_event_handler.gleam deleted file mode 100644 index b90af14..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/common/common_event_handler.gleam +++ /dev/null @@ -1,101 +0,0 @@ -import gleam/map.{type Map} -import showtime/internal/common/test_suite.{ - type TestEvent, type TestRun, CompletedTestRun, EndTest, EndTestRun, - EndTestSuite, OngoingTestRun, StartTest, StartTestRun, StartTestSuite, -} - -pub type TestState { - NotStarted - Running - Finished(num_modules: Int) -} - -pub type HandlerState { - HandlerState( - test_state: TestState, - num_done: Int, - events: Map(String, Map(String, TestRun)), - ) -} - -// This is the common event-handler (shared between erlang/JS targets) -// The main strategy is to collect the test-results in a map of maps: -// module_name -> -// test_name -> test_result -// It will also keep track of if it is running (i.e. did it receive the EndTestRun) -// so that the caller can determine when to print test-results -pub fn handle_event( - msg: TestEvent, - system_time: fn() -> Int, - state: HandlerState, -) { - let test_state = state.test_state - let num_done = state.num_done - let events = state.events - let #(updated_test_state, updated_num_done, updated_events) = case msg { - StartTestRun -> #(Running, num_done, events) - StartTestSuite(module) -> { - let maybe_module_events = map.get(events, module.name) - let new_events = case maybe_module_events { - Ok(_) -> events - Error(_) -> - events - |> map.insert(module.name, map.new()) - } - #(test_state, num_done, new_events) - } - StartTest(module, test) -> { - let current_time = system_time() - let maybe_module_events = map.get(events, module.name) - let new_events = case maybe_module_events { - Ok(module_events) -> { - let maybe_test_event = map.get(module_events, test.name) - case maybe_test_event { - Error(_) -> - events - |> map.insert( - module.name, - module_events - |> map.insert(test.name, OngoingTestRun(test, current_time)), - ) - Ok(_) -> events - } - } - Error(_) -> events - } - #(test_state, num_done, new_events) - } - EndTest(module, test, result) -> { - let current_time = system_time() - let maybe_module_events = map.get(events, module.name) - let new_events = case maybe_module_events { - Ok(module_events) -> { - let maybe_test_run = - module_events - |> map.get(test.name) - let updated_module_events = case maybe_test_run { - Ok(OngoingTestRun(test_function, started_at)) -> - module_events - |> map.insert( - test.name, - CompletedTestRun( - test_function, - current_time - started_at, - result, - ), - ) - Error(_) -> module_events - } - events - |> map.insert(module.name, updated_module_events) - } - Error(_) -> events - } - #(test_state, num_done, new_events) - } - EndTestSuite(_) -> #(test_state, num_done + 1, events) - EndTestRun(num_modules) -> #(Finished(num_modules), num_done, events) - _ -> #(Running, num_done, events) - } - HandlerState(updated_test_state, updated_num_done, updated_events) -} diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/common/test_result.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/common/test_result.gleam deleted file mode 100644 index a1d6bd9..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/common/test_result.gleam +++ /dev/null @@ -1,119 +0,0 @@ -import gleam/dynamic.{type Dynamic} -import gleam/map.{type Map} - -// These are all the types used for test-results -// NOTE: These are heavily used in the erlang/js ffi:s -// so any changes here are likely to break the ffi:s unless -// the corresponding change is introduced there -// -// Futhermore this has some erlang related names that should -// probably be cleaned up, but it is used by both the ffi:s - -// Currently only one reason, but could be possible to support -// more reasons in the future -pub type IgnoreReason { - Ignore -} - -// This is the return value from running the test-function -// or ignored if the test was ignored -pub type TestReturn { - TestFunctionReturn(value: Dynamic, output_buffer: List(String)) - Ignored(reason: IgnoreReason) -} - -// All data about an exception in the test function is captured -// in this type. -// This is also where the data about the assertions will end up (in reason) -pub type Exception { - ErlangException( - class: Class, - reason: Reason, - stacktrace: TraceList, - output_buffer: List(String), - ) -} - -// Alias for the test-result which is either a TestResult (passed test, ignored or a test-definition) -// or an Exception (failed test) -pub type TestResult = - Result(TestReturn, Exception) - -// Reason is either an assert equal (which is if the error was produced by gleeunit should) -// TODO: Add other asserts -// or it is a gleam error meaning that is was produced by showtime should -// TODO: Rename GleamError to ShowtimeError -pub type Reason { - AssertEqual(details: List(ReasonDetail)) - AssertNotEqual(details: List(ReasonDetail)) - AssertMatch(details: List(ReasonDetail)) - GleamError(details: GleamErrorDetail) - GleamAssert(value: Dynamic, line_no: Int) - GenericException(value: Dynamic) -} - -// ReasonDetail is the union-type used in erlang-exceptions where the reason -// is a list of such details -pub type ReasonDetail { - Module(name: String) - ReasonLine(line_no: Int) - Expression(expression: String) - Expected(value: Dynamic) - Value(value: Dynamic) - Pattern(pattern: String) -} - -// Gleam error detail is produced by showtime should and will hold all the information -// about the assertion (both expected and got) -pub type GleamErrorDetail { - LetAssert( - module: String, - function: String, - line_no: Int, - message: String, - value: Dynamic, - ) -} - -// Class is a part of standard erlang exceptions, but also used on js-side -// TODO: Extend to include a JS specific constructor -pub type Class { - ErlangError - Exit - Throw -} - -// The trace list is part of the standard erlang exception, but is also -// emulated on js-side. -// TODO: Maybe we need a js-version that contain some js-specific trace-elements -pub type TraceList { - TraceList(traces: List(Trace)) -} - -// Trace are the elements in the trace list in an erlang exception -// TODO: Maybe add a js-specific trace (since arity is not really a js attribute) -pub type Trace { - Trace(function: String, arity: Arity, extra_info: List(ExtraInfo)) - TraceModule( - module: String, - function: String, - arity: Arity, - extra_info: List(ExtraInfo), - ) -} - -// Extra info holds information about the file and line -// as well as some dynamic data in a map -// This is currently not used in the reporter -pub type ExtraInfo { - ErrorInfo(error_info: Map(Dynamic, Dynamic)) - File(filename: String) - Line(line_no: Int) -} - -// Arity is the erlang type for arity -// Can be either a number, or a list of arguments -pub type Arity { - Num(arity: Int) - ArgList(arg_list: List(Dynamic)) -} diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/common/test_suite.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/common/test_suite.gleam deleted file mode 100644 index eb58d64..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/common/test_suite.gleam +++ /dev/null @@ -1,63 +0,0 @@ -import gleam/option.{type Option} -import showtime/internal/common/test_result.{type TestResult} -import showtime/internal/common/cli.{type Capture} - -// The state (and result) of a test function -pub type TestRun { - OngoingTestRun(test_function: TestFunction, started_at: Int) - CompletedTestRun( - test_function: TestFunction, - total_time: Int, - result: TestResult, - ) -} - -// A test module (found by discovery) -pub type TestModule { - TestModule(name: String, path: Option(String)) -} - -// A test function -pub type TestFunction { - TestFunction(name: String) -} - -// A test suite is a test module together with the test functions -// that were collected from that module -pub type TestSuite { - TestSuite(module: TestModule, tests: List(TestFunction)) -} - -// Test event for the event handler -pub type TestEvent { - StartTestRun - StartTestSuite(test_module: TestModule) - StartTest(test_module: TestModule, test_function: TestFunction) - EndTest( - test_module: TestModule, - test_function: TestFunction, - result: TestResult, - ) - EndTestSuite(test_module: TestModule) - EndTestRun(num_modules: Int) -} - -// Interface for the module handler -pub type TestModuleHandler = - fn(TestModule) -> Nil - -// Interface for the event handler -pub type TestEventHandler = - fn(TestEvent) -> Nil - -// Interface for the module collector -pub type ModuleCollector = - fn(TestModuleHandler) -> List(TestModule) - -// Interface for the function collector -pub type TestFunctionCollector = - fn(TestModule) -> TestSuite - -// Interface for the test runner -pub type TestRunner = - fn(TestSuite, TestEventHandler, List(String), Capture) -> Nil 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 diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/reports/compare.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/reports/compare.gleam deleted file mode 100644 index 5ccddee..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/reports/compare.gleam +++ /dev/null @@ -1,42 +0,0 @@ -import gleam/dynamic.{type Dynamic} -import gleam/string -import showtime/internal/reports/styles.{expected_highlight, got_highlight} -import gap.{compare_lists, compare_strings} -import gap/styling.{from_comparison, highlight, to_styled_comparison} - -pub fn compare(expected: Dynamic, got: Dynamic) -> #(String, String) { - let expected_as_list = - expected - |> dynamic.list(dynamic.dynamic) - let got_as_list = - got - |> dynamic.list(dynamic.dynamic) - let expected_as_string = - expected - |> dynamic.string() - let got_as_string = - got - |> dynamic.string() - case expected_as_list, got_as_list, expected_as_string, got_as_string { - Ok(expected_list), Ok(got_list), _, _ -> { - let comparison = - compare_lists(expected_list, got_list) - |> from_comparison() - |> highlight(expected_highlight, got_highlight, fn(item) { item }) - |> to_styled_comparison() - #(comparison.first, comparison.second) - } - _, _, Ok(expected_string), Ok(got_string) -> { - let comparison = - compare_strings(expected_string, got_string) - |> from_comparison() - |> highlight(expected_highlight, got_highlight, fn(item) { item }) - |> to_styled_comparison() - #(comparison.first, comparison.second) - } - _, _, _, _ -> #( - expected_highlight(string.inspect(expected)), - got_highlight(string.inspect(got)), - ) - } -} diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/reports/formatter.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/reports/formatter.gleam deleted file mode 100644 index 8c1a6ac..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/reports/formatter.gleam +++ /dev/null @@ -1,480 +0,0 @@ -import gleam/io -import gleam/int -import gleam/list -import gleam/string -import gleam/option.{type Option, None, Some} -import gleam/map.{type Map} -import gleam/dynamic.{type Dynamic} -import showtime/internal/common/test_result.{ - type GleamErrorDetail, type ReasonDetail, type Trace, AssertEqual, AssertMatch, - AssertNotEqual, Expected, Expression, GenericException, GleamAssert, - GleamError, Ignored, LetAssert, Pattern, Trace, TraceModule, Value, -} -import showtime/internal/common/test_suite.{type TestRun, CompletedTestRun} -import showtime/tests/should.{type Assertion, Eq, Fail, IsError, IsOk, NotEq} -import showtime/internal/reports/styles.{ - error_style, expected_highlight, failed_style, function_style, got_highlight, - heading_style, ignored_style, not_style, passed_style, stacktrace_style, -} -import showtime/internal/reports/compare.{compare} -import showtime/internal/reports/table.{ - AlignLeft, AlignLeftOverflow, AlignRight, Content, Separator, StyledContent, - Table, align_table, to_string, -} -import showtime/tests/meta.{type Meta} - -type GleeUnitAssertionType { - GleeUnitAssertEqual(message: String) - GleeUnitAssertNotEqual(message: String) - GleeUnitAssertMatch(message: String) -} - -type ModuleAndTest { - ModuleAndTestRun(module_name: String, test_run: TestRun) -} - -type UnifiedError { - UnifiedError( - meta: Option(Meta), - reason: String, - message: String, - expected: String, - got: String, - line: Option(Int), - stacktrace: List(Trace), - ) -} - -pub fn create_test_report(test_results: Map(String, Map(String, TestRun))) { - let all_test_runs = - test_results - |> map.values() - |> list.flat_map(map.values) - let failed_test_runs = - test_results - |> map.to_list() - |> list.flat_map(fn(entry) { - let #(module_name, test_module_results) = entry - test_module_results - |> map.values() - |> list.filter_map(fn(test_run) { - case test_run { - CompletedTestRun(_test_function, _, result) -> - case result { - Error(_) -> Ok(ModuleAndTestRun(module_name, test_run)) - Ok(Ignored(_)) -> Error(Nil) - Ok(_) -> Error(Nil) - } - _ -> { - test_run - |> io.debug() - Error(Nil) - } - } - }) - }) - - let ignored_test_runs = - test_results - |> map.to_list() - |> list.flat_map(fn(entry) { - let #(module_name, test_module_results) = entry - test_module_results - |> map.values() - |> list.filter_map(fn(test_run) { - case test_run { - CompletedTestRun(test_function, _, result) -> - case result { - Ok(Ignored(reason)) -> - Ok(#(module_name <> "." <> test_function.name, reason)) - _ -> Error(Nil) - } - _ -> Error(Nil) - } - }) - }) - - let failed_tests_report = - failed_test_runs - |> list.filter_map(fn(module_and_test_run) { - case module_and_test_run.test_run { - CompletedTestRun(test_function, _total_time, result) -> - case result { - Error(exception) -> - case exception.reason { - AssertEqual(reason_details) -> - Ok(format_reason( - erlang_error_to_unified( - reason_details, - GleeUnitAssertEqual("Assert equal"), - exception.stacktrace.traces, - ), - module_and_test_run.module_name, - test_function.name, - exception.output_buffer, - )) - AssertNotEqual(reason_details) -> - Ok(format_reason( - erlang_error_to_unified( - reason_details, - GleeUnitAssertNotEqual("Assert not equal"), - exception.stacktrace.traces, - ), - module_and_test_run.module_name, - test_function.name, - exception.output_buffer, - )) - AssertMatch(reason_details) -> - Ok(format_reason( - erlang_error_to_unified( - reason_details, - GleeUnitAssertMatch("Assert match"), - exception.stacktrace.traces, - ), - module_and_test_run.module_name, - test_function.name, - exception.output_buffer, - )) - GleamError(reason) -> - Ok(format_reason( - gleam_error_to_unified(reason, exception.stacktrace.traces), - module_and_test_run.module_name, - test_function.name, - exception.output_buffer, - )) - // GleamAssert(value) -> Error(Nil) - GleamAssert(value, line_no) -> - Ok(format_reason( - UnifiedError( - None, - "gleam assert", - "Assert failed", - "Patterns should match", - error_style(string.inspect(value)), - Some(line_no), - exception.stacktrace.traces, - ), - module_and_test_run.module_name, - test_function.name, - exception.output_buffer, - )) - GenericException(value) -> - Ok(format_reason( - UnifiedError( - None, - "generic exception", - "Test function threw an exception", - "Exception in test function", - error_style(string.inspect(value)), - None, - exception.stacktrace.traces, - ), - module_and_test_run.module_name, - test_function.name, - exception.output_buffer, - )) - other -> { - io.println("Other: " <> string.inspect(other)) - panic - Error(Nil) - } - } - _ -> Error(Nil) - } - _ -> Error(Nil) - } - }) - |> list.fold([], fn(rows, test_rows) { list.append(rows, test_rows) }) - - let all_test_execution_time_reports = - all_test_runs - |> list.filter_map(fn(test_run) { - case test_run { - CompletedTestRun(test_function, total_time, _) -> - Ok(test_function.name <> ": " <> int.to_string(total_time) <> " ms") - _ -> Error(Nil) - } - }) - let _execution_times_report = - all_test_execution_time_reports - |> string.join("\n") - - let all_tests_count = - all_test_runs - |> list.length() - let ignored_tests_count = - ignored_test_runs - |> list.length() - let failed_tests_count = - failed_test_runs - |> list.length() - - let passed = - passed_style( - int.to_string(all_tests_count - failed_tests_count - ignored_tests_count) <> " passed", - ) - let failed = failed_style(int.to_string(failed_tests_count) <> " failed") - let ignored = case ignored_tests_count { - 0 -> "" - _ -> ", " <> ignored_style(int.to_string(ignored_tests_count) <> " ignored") - } - - let failed_tests_table = - Table(None, failed_tests_report) - |> align_table() - |> to_string() - - let test_report = - "\n" <> failed_tests_table <> "\n" <> passed <> ", " <> failed <> ignored - #(test_report, failed_tests_count) -} - -fn erlang_error_to_unified( - error_details: List(ReasonDetail), - assertion_type: GleeUnitAssertionType, - stacktrace: List(Trace), -) { - error_details - |> list.fold( - UnifiedError( - None, - "not_set", - assertion_type.message, - "", - "", - None, - stacktrace, - ), - fn(unified, reason) { - case reason { - Expression(expression) -> UnifiedError(..unified, reason: expression) - Expected(value) -> - case assertion_type { - GleeUnitAssertEqual(_messaged) -> - UnifiedError( - ..unified, - expected: expected_highlight(string.inspect(value)), - ) - _ -> unified - } - Value(value) -> - case assertion_type { - GleeUnitAssertNotEqual(_message) -> - UnifiedError( - ..unified, - expected: not_style("not ") <> string.inspect(value), - got: got_highlight(string.inspect(value)), - ) - _ -> - UnifiedError(..unified, got: got_highlight(string.inspect(value))) - } - Pattern(pattern) -> - case pattern { - "{ ok , _ }" -> - UnifiedError(..unified, expected: expected_highlight("Ok(_)")) - "{ error , _ }" -> - UnifiedError(..unified, expected: expected_highlight("Error(_)")) - _ -> unified - } - _ -> unified - } - }, - ) -} - -fn gleam_error_to_unified( - gleam_error: GleamErrorDetail, - stacktrace: List(Trace), -) -> UnifiedError { - case gleam_error { - LetAssert(_module, _function, _line_no, _message, value) -> { - let result: Result(Dynamic, Assertion(Dynamic, Dynamic)) = - dynamic.unsafe_coerce(value) - let assert Error(assertion) = result - case assertion { - Eq(got, expected, meta) -> { - let #(expected, got) = compare(expected, got) - UnifiedError( - meta, - "assert", - "Assert equal", - expected, - got, - None, - stacktrace, - ) - } - NotEq(got, expected, meta) -> - UnifiedError( - meta, - "assert", - "Assert not equal", - not_style("not ") <> string.inspect(expected), - string.inspect(got), - None, - stacktrace, - ) - IsOk(got, meta) -> - UnifiedError( - meta, - "assert", - "Assert is Ok", - expected_highlight("Ok(_)"), - got_highlight(string.inspect(got)), - None, - stacktrace, - ) - IsError(got, meta) -> - UnifiedError( - meta, - "assert", - "Assert is Ok", - expected_highlight("Error(_)"), - got_highlight(string.inspect(got)), - None, - stacktrace, - ) - Fail(meta) -> - UnifiedError( - meta, - "assert", - "Assert is Ok", - got_highlight("should.fail()"), - got_highlight("N/A - test always expected to fail"), - None, - stacktrace, - ) - } - } - } -} - -fn format_reason( - error: UnifiedError, - module: String, - function: String, - output_buffer: List(String), -) { - let meta = case error.meta { - Some(meta) -> - Some([ - AlignRight(StyledContent(heading_style("Description")), 2), - Separator(": "), - AlignLeft(Content(meta.description), 0), - ]) - - None -> None - } - - let stacktrace = - error.stacktrace - |> list.map(fn(trace) { - case trace { - Trace(function, _, _) if function == "" -> "(anonymous)" - TraceModule(module, function, _, _) if function == "" -> - module <> "." <> "(anonymous)" - Trace(function, _, _) -> function - TraceModule(module, function, _, _) -> module <> "." <> function - } - }) - let stacktrace_rows = case stacktrace { - [] -> [] - [first, ..rest] -> { - let first_row = - Some([ - AlignRight(StyledContent(heading_style("Stacktrace")), 2), - Separator(": "), - AlignLeft(StyledContent(stacktrace_style(first)), 0), - ]) - let rest_rows = - rest - |> list.map(fn(row) { - Some([ - AlignRight(Content(""), 2), - Separator(" "), - AlignLeft(StyledContent(stacktrace_style(row)), 0), - ]) - }) - [first_row, ..rest_rows] - } - } - - let output_rows = case - output_buffer - |> list.reverse() - |> list.map(fn(row) { string.trim_right(row) }) - { - [] -> [] - [first, ..rest] -> { - let first_row = - Some([ - AlignRight(StyledContent(heading_style("Output")), 2), - Separator(": "), - AlignLeftOverflow(StyledContent(stacktrace_style(first)), 0), - ]) - let rest_rows = - rest - |> list.map(fn(row) { - Some([ - AlignRight(Content(""), 2), - Separator(" "), - AlignLeftOverflow(StyledContent(stacktrace_style(row)), 0), - ]) - }) - [first_row, ..rest_rows] - } - } - - let line = - error.line - |> option.map(fn(line) { ":" <> int.to_string(line) }) - |> option.unwrap("") - - let arrow = - string.join( - list.repeat( - "-", - string.length(module) + 1 + { - string.length(function) + string.length(line) - } / 2, - ), - "", - ) <> "⌄" - let standard_table_rows = [ - Some([ - AlignRight(StyledContent(error_style("Failed")), 2), - Separator(": "), - AlignLeft(Content(arrow), 0), - ]), - Some([ - AlignRight(StyledContent(heading_style("Test")), 2), - Separator(": "), - AlignLeft( - StyledContent(module <> "." <> function_style(function <> line)), - 0, - ), - ]), - meta, - Some([ - AlignRight(StyledContent(heading_style("Expected")), 2), - Separator(": "), - AlignLeftOverflow(StyledContent(error.expected), 0), - ]), - Some([ - AlignRight(StyledContent(heading_style("Got")), 2), - Separator(": "), - AlignLeftOverflow(StyledContent(error.got), 0), - ]), - ] - standard_table_rows - |> list.append(stacktrace_rows) - |> list.append(output_rows) - |> list.append([ - Some([ - AlignRight(Content(""), 0), - AlignRight(Content(""), 0), - AlignRight(Content(""), 0), - ]), - ]) - |> list.filter_map(fn(row) { option.to_result(row, Nil) }) -} diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/reports/styles.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/reports/styles.gleam deleted file mode 100644 index b051dd3..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/reports/styles.gleam +++ /dev/null @@ -1,84 +0,0 @@ -import gleam_community/ansi -import gleam/list -import gleam/string -import gleam/bit_array - -pub fn passed_style(text) { - bold_green(text) -} - -pub fn failed_style(text) { - bold_red(text) -} - -pub fn ignored_style(text) { - bold_yellow(text) -} - -pub fn error_style(text) { - bold_red(text) -} - -pub fn expected_highlight(text) { - bold_green(text) -} - -pub fn got_highlight(text) { - bold_red(text) -} - -pub fn not_style(text) { - ansi.bold(text) -} - -pub fn module_style(text: String) { - ansi.cyan(text) -} - -pub fn heading_style(text: String) { - ansi.cyan(text) -} - -pub fn function_style(text: String) { - bold_cyan(text) -} - -pub fn stacktrace_style(text: String) { - text -} - -fn bold_red(text: String) { - ansi.bold(ansi.red(text)) -} - -fn bold_green(text) { - ansi.bold(ansi.green(text)) -} - -fn bold_yellow(text) { - ansi.bold(ansi.yellow(text)) -} - -fn bold_cyan(text) { - ansi.bold(ansi.cyan(text)) -} - -pub fn strip_style(text) { - let #(new_text, _) = - text - |> string.to_graphemes() - |> list.fold( - #("", False), - fn(acc, char) { - let #(str, removing) = acc - let bit_char = bit_array.from_string(char) - case bit_char, removing { - <<0x1b>>, _ -> #(str, True) - <<0x6d>>, True -> #(str, False) - _, True -> #(str, True) - _, False -> #(str <> char, False) - } - }, - ) - new_text -} diff --git a/aoc2023/build/packages/adglent/src/showtime/internal/reports/table.gleam b/aoc2023/build/packages/adglent/src/showtime/internal/reports/table.gleam deleted file mode 100644 index f8bc00c..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/internal/reports/table.gleam +++ /dev/null @@ -1,148 +0,0 @@ -import gleam/list -import gleam/string -import gleam/int -import gleam/option.{type Option} -import showtime/internal/reports/styles.{strip_style} - -pub type Content { - Content(unstyled_text: String) - StyledContent(styled_text: String) -} - -pub type Col { - AlignRight(content: Content, margin: Int) - AlignLeft(content: Content, margin: Int) - AlignRightOverflow(content: Content, margin: Int) - AlignLeftOverflow(content: Content, margin: Int) - Separator(char: String) - Aligned(content: String) -} - -pub type Table { - Table(header: Option(String), rows: List(List(Col))) -} - -pub fn to_string(table: Table) -> String { - let rows = - table.rows - |> list.map(fn(row) { - row - |> list.filter_map(fn(col) { - case col { - Separator(char) -> Ok(char) - Aligned(content) -> Ok(content) - _ -> Error(Nil) - } - }) - |> string.join("") - }) - |> string.join("\n") - let header = - table.header - |> option.map(fn(header) { header <> "\n" }) - |> option.unwrap("") - header <> rows -} - -pub fn align_table(table: Table) -> Table { - let cols = - table.rows - |> list.transpose() - let col_width = - cols - |> list.map(fn(col) { - col - |> list.map(fn(content) { - case content { - AlignRight(Content(unstyled), _) -> unstyled - AlignRight(StyledContent(styled), _) -> strip_style(styled) - AlignLeft(Content(unstyled), _) -> unstyled - AlignLeft(StyledContent(styled), _) -> strip_style(styled) - AlignLeftOverflow(_, _) -> "" - AlignRightOverflow(_, _) -> "" - Separator(char) -> char - Aligned(content) -> content - } - }) - |> list.fold(0, fn(max, str) { int.max(max, string.length(str)) }) - }) - let aligned_col = - cols - |> list.zip(col_width) - |> list.map(fn(col_and_width) { - let #(col, width) = col_and_width - col - |> list.map(fn(content) { - case content { - AlignRight(Content(unstyled), margin) -> - Aligned(pad_left( - unstyled, - width + margin - string.length(unstyled), - " ", - )) - AlignRight(StyledContent(styled), margin) -> - Aligned(pad_left( - styled, - width + margin - string.length(strip_style(styled)), - " ", - )) - AlignRightOverflow(Content(unstyled), margin) -> - Aligned(pad_left( - unstyled, - width + margin - string.length(unstyled), - " ", - )) - AlignRightOverflow(StyledContent(styled), margin) -> - Aligned(pad_left( - styled, - width + margin - string.length(strip_style(styled)), - " ", - )) - AlignLeft(Content(unstyled), margin) -> - Aligned(pad_right( - unstyled, - width + margin - string.length(unstyled), - " ", - )) - AlignLeft(StyledContent(styled), margin) -> - Aligned(pad_right( - styled, - width + margin - string.length(strip_style(styled)), - " ", - )) - AlignLeftOverflow(Content(unstyled), margin) -> - Aligned(pad_right( - unstyled, - width + margin - string.length(unstyled), - " ", - )) - AlignLeftOverflow(StyledContent(styled), margin) -> - Aligned(pad_right( - styled, - width + margin - string.length(strip_style(styled)), - " ", - )) - Separator(char) -> Separator(char) - Aligned(content) -> Aligned(content) - } - }) - }) - let aligned_rows = - aligned_col - |> list.transpose() - Table(..table, rows: aligned_rows) -} - -fn pad_left(str: String, num: Int, char: String) { - let padding = - list.repeat(char, num) - |> string.join("") - padding <> str -} - -fn pad_right(str: String, num: Int, char: String) { - let padding = - list.repeat(char, num) - |> string.join("") - str <> padding -} diff --git a/aoc2023/build/packages/adglent/src/showtime/tests/meta.gleam b/aoc2023/build/packages/adglent/src/showtime/tests/meta.gleam deleted file mode 100644 index cbba414..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/tests/meta.gleam +++ /dev/null @@ -1,3 +0,0 @@ -pub type Meta { - Meta(description: String, tags: List(String)) -} diff --git a/aoc2023/build/packages/adglent/src/showtime/tests/should.gleam b/aoc2023/build/packages/adglent/src/showtime/tests/should.gleam deleted file mode 100644 index 71578c7..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/tests/should.gleam +++ /dev/null @@ -1,113 +0,0 @@ -import gleam/option.{type Option, None, Some} -import showtime/tests/meta.{type Meta} - -pub type Assertion(t, e) { - Eq(a: t, b: t, meta: Option(Meta)) - NotEq(a: t, b: t, meta: Option(Meta)) - IsOk(a: Result(t, e), meta: Option(Meta)) - IsError(a: Result(t, e), meta: Option(Meta)) - Fail(meta: Option(Meta)) -} - -pub fn equal(a: t, b: t) { - evaluate(Eq(a, b, None)) -} - -pub fn equal_meta(a: t, b: t, meta: Meta) { - evaluate(Eq(a, b, Some(meta))) -} - -pub fn not_equal(a: t, b: t) { - evaluate(NotEq(a, b, None)) -} - -pub fn not_equal_meta(a: t, b: t, meta: Meta) { - evaluate(NotEq(a, b, Some(meta))) -} - -pub fn be_ok(a: Result(o, e)) { - evaluate(IsOk(a, None)) - let assert Ok(value) = a - value -} - -pub fn be_ok_meta(a: Result(o, e), meta: Meta) { - evaluate(IsOk(a, Some(meta))) -} - -pub fn be_error(a: Result(o, e)) { - evaluate(IsError(a, None)) - let assert Error(value) = a - value -} - -pub fn be_error_meta(a: Result(o, e), meta: Meta) { - evaluate(IsError(a, Some(meta))) -} - -pub fn fail() { - evaluate(Fail(None)) -} - -pub fn fail_meta(meta: Meta) { - evaluate(Fail(Some(meta))) -} - -pub fn be_true(a: Bool) { - a - |> equal(True) -} - -pub fn be_true_meta(a: Bool, meta: Meta) { - a - |> equal_meta(True, meta) -} - -pub fn be_false(a: Bool) { - a - |> equal(False) -} - -pub fn be_false_meta(a: Bool, meta: Meta) { - a - |> equal_meta(False, meta) -} - -@external(erlang, "showtime_ffi", "gleam_error") -fn gleam_error(value: Result(Nil, Assertion(a, b))) -> Nil - -pub fn evaluate(assertion) -> Nil { - case assertion { - Eq(a, b, _meta) -> - case a == b { - True -> Nil - False -> { - gleam_error(Error(assertion)) - } - } - NotEq(a, b, _meta) -> - case a != b { - True -> Nil - False -> { - gleam_error(Error(assertion)) - } - } - IsOk(a, _meta) -> - case a { - Ok(_) -> Nil - Error(_) -> { - gleam_error(Error(assertion)) - } - } - IsError(a, _meta) -> - case a { - Error(_) -> Nil - Ok(_) -> { - gleam_error(Error(assertion)) - } - } - Fail(_meta) -> { - gleam_error(Error(assertion)) - } - } -} diff --git a/aoc2023/build/packages/adglent/src/showtime/tests/test.gleam b/aoc2023/build/packages/adglent/src/showtime/tests/test.gleam deleted file mode 100644 index 730f943..0000000 --- a/aoc2023/build/packages/adglent/src/showtime/tests/test.gleam +++ /dev/null @@ -1,57 +0,0 @@ -import showtime/tests/should -import showtime/tests/meta.{type Meta} -import gleam/io - -pub type Test { - Test(meta: Meta, test_function: fn() -> Nil) -} - -pub type MetaShould(t) { - MetaShould(equal: fn(t, t) -> Nil, not_equal: fn(t, t) -> Nil) -} - -pub fn test(meta: Meta, test_function: fn(Meta) -> Nil) { - Test(meta, fn() { test_function(meta) }) -} - -pub fn with_meta(meta: Meta, test_function: fn(MetaShould(a)) -> Nil) { - Test( - meta, - fn() { - test_function(MetaShould( - fn(a, b) { equal(a, b, meta) }, - fn(a, b) { not_equal(a, b, meta) }, - )) - }, - ) -} - -pub fn equal(a: t, b: t, meta: Meta) { - io.debug(a) - io.debug(b) - should.equal_meta(a, b, meta) -} - -pub fn not_equal(a: t, b: t, meta: Meta) { - should.equal_meta(a, b, meta) -} - -pub fn be_ok(a: Result(o, e), meta: Meta) { - should.be_ok_meta(a, meta) -} - -pub fn be_error(a: Result(o, e), meta: Meta) { - should.be_error_meta(a, meta) -} - -pub fn fail(meta: Meta) { - should.fail_meta(meta) -} - -pub fn be_true(a: Bool, meta: Meta) { - should.be_true_meta(a, meta) -} - -pub fn be_false(a: Bool, meta: Meta) { - should.be_false_meta(a, meta) -} |