refactor: use qualified type access and rename CliOptions

Author: jtdowney

src/unitest.gleam

@@ -19,12 +19,10 @@ import gleam_community/ansi
 import prng/random
 import simplifile
 import spinner
-import unitest/internal/cli.{type Reporter, type SortOrder}
-import unitest/internal/discover.{type Test}
+import unitest/internal/cli
+import unitest/internal/discover
 import unitest/internal/format_table
-import unitest/internal/runner.{
-  type PoolResult, type Progress, type Report, type TestResult,
-}
+import unitest/internal/runner
 
 const yield_every_n_tests = 5
 
@@ -53,7 +51,7 @@ pub type ResolvedExecutionMode {
 
 @internal
 pub type CliAction {
-  RunWithCliOptions(cli.CliOptions)
+  RunWithCliOptions(cli.Options)
   ShowCliMessage(message: String, exit_code: Int)
 }
 
@@ -274,7 +272,7 @@ fn wants_help(args: List(String)) -> Bool {
   list.contains(args, "--help") || list.contains(args, "-h")
 }
 
-fn run_with_cli_opts(cli_opts: cli.CliOptions, options: Options) -> Nil {
+fn run_with_cli_opts(cli_opts: cli.Options, options: Options) -> Nil {
   let use_color = should_use_color(cli_opts.no_color)
   let tests = discover.discover_from_fs(options.test_directory)
 
@@ -362,8 +360,8 @@ fn execute_and_finish(
   seed: Int,
   mode: ResolvedExecutionMode,
   use_color: Bool,
-  reporter: Reporter,
-  sort_order: SortOrder,
+  reporter: cli.Reporter,
+  sort_order: cli.SortOrder,
   sort_reversed: Bool,
   check_results: Bool,
 ) -> Nil {
@@ -426,20 +424,24 @@ fn execute_and_finish(
 }
 
 type OnResultCallback =
-  fn(TestResult, Progress, fn() -> Nil) -> Nil
+  fn(runner.TestResult, runner.Progress, fn() -> Nil) -> Nil
 
 type CleanupCallback =
   fn(runner.ExecuteResult) -> Nil
 
 fn build_on_result_callback(
-  reporter: Reporter,
+  reporter: cli.Reporter,
   use_color: Bool,
-  sort_order: SortOrder,
+  sort_order: cli.SortOrder,
   sort_reversed: Bool,
 ) -> #(OnResultCallback, CleanupCallback) {
   case reporter {
     cli.DotReporter -> {
-      let on_result = fn(result: TestResult, _progress: Progress, continue) {
+      let on_result = fn(
+        result: runner.TestResult,
+        _progress: runner.Progress,
+        continue,
+      ) {
         io.print(runner.outcome_char(result.outcome, use_color))
         continue()
       }
@@ -452,7 +454,11 @@ fn build_on_result_callback(
         |> spinner.with_colour(ansi.cyan)
         |> spinner.start
 
-      let on_result = fn(_result: TestResult, progress: Progress, continue) {
+      let on_result = fn(
+        _result: runner.TestResult,
+        progress: runner.Progress,
+        continue,
+      ) {
         let text =
           "Running tests... "
           <> int.to_string(progress.current)
@@ -482,7 +488,7 @@ fn build_on_result_callback(
 }
 
 @internal
-pub fn exit_code(report: Report) -> Int {
+pub fn exit_code(report: runner.Report) -> Int {
   case report.failed > 0 {
     True -> 1
     False -> 0
@@ -500,7 +506,7 @@ fn now_ms() -> Int
 @external(erlang, "unitest_ffi", "run_test_async")
 @external(javascript, "./unitest_ffi.mjs", "runTestAsync")
 fn run_test_async(
-  t: Test,
+  t: discover.Test,
   package_name: String,
   check_results: Bool,
   k: fn(runner.TestRunResult) -> Nil,
@@ -509,15 +515,15 @@ fn run_test_async(
 @external(erlang, "unitest_ffi", "start_module_pool")
 @external(javascript, "./unitest_ffi.mjs", "startModulePool")
 fn start_module_pool(
-  module_groups: List(List(Test)),
+  module_groups: List(List(discover.Test)),
   package_name: String,
   check_results: Bool,
   workers: Int,
 ) -> Nil
 
 @external(erlang, "unitest_ffi", "receive_pool_result")
 @external(javascript, "./unitest_ffi.mjs", "receivePoolResult")
-fn receive_pool_result(callback: fn(PoolResult) -> Nil) -> Nil
+fn receive_pool_result(callback: fn(runner.PoolResult) -> Nil) -> Nil
 
 @target(erlang)
 fn yield_then(next: fn() -> Nil) -> Nil {

src/unitest/internal/cli.gleam

@@ -30,8 +30,8 @@ pub type SortOrder {
   NameSort
 }
 
-pub type CliOptions {
-  CliOptions(
+pub type Options {
+  Options(
     seed: Option(Int),
     filter: Filter,
     no_color: Bool,
@@ -42,7 +42,7 @@ pub type CliOptions {
   )
 }
 
-pub fn parse(args: List(String)) -> Result(CliOptions, String) {
+pub fn parse(args: List(String)) -> Result(Options, String) {
   let command =
     clip.command({
       use seed_result <- clip.parameter
@@ -149,7 +149,7 @@ pub fn parse(args: List(String)) -> Result(CliOptions, String) {
   use reporter <- result.try(parse_reporter(reporter_str))
   use sort_order <- result.try(parse_sort_order(sort_str))
   use validated_workers <- result.try(validate_workers(workers))
-  Ok(CliOptions(
+  Ok(Options(
     seed:,
     filter:,
     no_color:,

src/unitest/internal/discover.gleam

@@ -1,6 +1,4 @@
-import glance.{
-  type Attribute, type Expression, type Function, type Span, type Statement,
-}
+import glance
 import gleam/bit_array
 import gleam/list
 import gleam/result
@@ -22,7 +20,7 @@ pub type Test {
 }
 
 pub type ParsedTest {
-  ParsedTest(name: String, tags: List(String), byte_span: Span)
+  ParsedTest(name: String, tags: List(String), byte_span: glance.Span)
 }
 
 pub fn path_to_module(path: String, base_path: String) -> String {
@@ -105,7 +103,10 @@ pub fn parse_module_for_target(
   })
 }
 
-fn is_available_for_target(attributes: List(Attribute), target: String) -> Bool {
+fn is_available_for_target(
+  attributes: List(glance.Attribute),
+  target: String,
+) -> Bool {
   let target_attrs = list.filter(attributes, fn(attr) { attr.name == "target" })
 
   case target_attrs {
@@ -114,7 +115,7 @@ fn is_available_for_target(attributes: List(Attribute), target: String) -> Bool
   }
 }
 
-fn matches_target(attr: Attribute, target: String) -> Bool {
+fn matches_target(attr: glance.Attribute, target: String) -> Bool {
   case attr.arguments {
     [glance.Variable(name: attr_target, ..)] -> attr_target == target
     _ -> True
@@ -131,24 +132,24 @@ fn current_target() -> String {
   "javascript"
 }
 
-fn parse_function(func: Function) -> ParsedTest {
+fn parse_function(func: glance.Function) -> ParsedTest {
   let tags = extract_tags_from_body(func.body)
   ParsedTest(name: func.name, tags: list.unique(tags), byte_span: func.location)
 }
 
-fn extract_tags_from_body(statements: List(Statement)) -> List(String) {
+fn extract_tags_from_body(statements: List(glance.Statement)) -> List(String) {
   list.flat_map(statements, extract_tags_from_statement)
 }
 
-fn extract_tags_from_statement(stmt: Statement) -> List(String) {
+fn extract_tags_from_statement(stmt: glance.Statement) -> List(String) {
   case stmt {
     glance.Use(function: func, ..) -> extract_tags_from_expr(func)
     glance.Expression(expr) -> extract_tags_from_expr(expr)
     _ -> []
   }
 }
 
-fn extract_tags_from_expr(expr: Expression) -> List(String) {
+fn extract_tags_from_expr(expr: glance.Expression) -> List(String) {
   case expr {
     // unitest.tag("slow")
     glance.Call(
@@ -176,14 +177,18 @@ fn extract_tags_from_expr(expr: Expression) -> List(String) {
   }
 }
 
-fn extract_single_tag(args: List(glance.Field(Expression))) -> List(String) {
+fn extract_single_tag(
+  args: List(glance.Field(glance.Expression)),
+) -> List(String) {
   case args {
     [glance.UnlabelledField(glance.String(value: tag, ..))] -> [tag]
     _ -> []
   }
 }
 
-fn extract_tags_list(args: List(glance.Field(Expression))) -> List(String) {
+fn extract_tags_list(
+  args: List(glance.Field(glance.Expression)),
+) -> List(String) {
   case args {
     [glance.UnlabelledField(glance.List(elements: elements, ..))] ->
       list.filter_map(elements, fn(elem) {

src/unitest/internal/format_table.gleam

@@ -4,13 +4,13 @@ import gleam/order
 import gleam/string
 import gleam_community/ansi
 import tobble
-import unitest/internal/cli.{type SortOrder}
-import unitest/internal/runner.{type TestResult}
+import unitest/internal/cli
+import unitest/internal/runner
 
 pub fn render_table(
-  results: List(TestResult),
+  results: List(runner.TestResult),
   use_color: Bool,
-  sort_order: SortOrder,
+  sort_order: cli.SortOrder,
   sort_reversed: Bool,
 ) -> String {
   let sorted_results = sort_results(results, sort_order, sort_reversed)
@@ -64,10 +64,10 @@ fn format_duration(outcome: runner.Outcome, duration_ms: Int) -> String {
 }
 
 fn sort_results(
-  results: List(TestResult),
-  sort_order: SortOrder,
+  results: List(runner.TestResult),
+  sort_order: cli.SortOrder,
   sort_reversed: Bool,
-) -> List(TestResult) {
+) -> List(runner.TestResult) {
   case sort_order, sort_reversed {
     cli.NativeSort, False -> results
     cli.NativeSort, True -> list.reverse(results)
@@ -79,12 +79,16 @@ fn sort_results(
   }
 }
 
-fn compare_by_name(a: TestResult, b: TestResult) -> order.Order {
+fn compare_by_name(a: runner.TestResult, b: runner.TestResult) -> order.Order {
   string.compare(a.item.module, b.item.module)
   |> order.lazy_break_tie(fn() { string.compare(a.item.name, b.item.name) })
 }
 
-fn compare_by_time(a: TestResult, b: TestResult, reversed: Bool) -> order.Order {
+fn compare_by_time(
+  a: runner.TestResult,
+  b: runner.TestResult,
+  reversed: Bool,
+) -> order.Order {
   case a.outcome, b.outcome {
     runner.Skipped, runner.Skipped -> order.Eq
     runner.Skipped, runner.Passed | runner.Skipped, runner.Failed(_) -> order.Gt

src/unitest/internal/js_decode.gleam

@@ -1,13 +1,10 @@
 import gleam/dynamic.{type Dynamic}
 import gleam/dynamic/decode
-import unitest/internal/discover.{type Test}
-import unitest/internal/runner.{type PoolResult, type TestRunResult}
-import unitest/internal/test_failure.{
-  type AssertKind, type AssertedExpr, type ExprKind, type PanicKind,
-  type TestFailure,
-}
+import unitest/internal/discover
+import unitest/internal/runner
+import unitest/internal/test_failure.{type TestFailure}
 
-pub fn decode_test_run_result(raw: Dynamic) -> TestRunResult {
+pub fn decode_test_run_result(raw: Dynamic) -> runner.TestRunResult {
   let decoder = {
     use tag <- decode.field("kind", decode.string)
     case tag {
@@ -28,14 +25,14 @@ pub fn decode_test_run_result(raw: Dynamic) -> TestRunResult {
 }
 
 pub fn wrap_pool_result(
-  item: Test,
-  result: TestRunResult,
+  item: discover.Test,
+  result: runner.TestRunResult,
   duration_ms: Int,
-) -> PoolResult {
+) -> runner.PoolResult {
   runner.PoolResult(item:, result:, duration_ms:)
 }
 
-pub fn make_crash_error(message: String) -> TestRunResult {
+pub fn make_crash_error(message: String) -> runner.TestRunResult {
   runner.RunError(test_failure.TestFailure(
     message:,
     file: "",
@@ -67,7 +64,7 @@ fn decode_test_failure() -> decode.Decoder(TestFailure) {
   ))
 }
 
-fn decode_panic_kind_inner() -> decode.Decoder(PanicKind) {
+fn decode_panic_kind_inner() -> decode.Decoder(test_failure.PanicKind) {
   use tag <- decode.field("type", decode.string)
   case tag {
     "assert" -> {
@@ -101,7 +98,7 @@ fn decode_panic_kind_inner() -> decode.Decoder(PanicKind) {
   }
 }
 
-fn decode_assert_kind_inner() -> decode.Decoder(AssertKind) {
+fn decode_assert_kind_inner() -> decode.Decoder(test_failure.AssertKind) {
   let default_expr = test_failure.AssertedExpr(0, 0, test_failure.Unevaluated)
 
   use tag <- decode.field("type", decode.string)
@@ -140,14 +137,14 @@ fn decode_assert_kind_inner() -> decode.Decoder(AssertKind) {
   }
 }
 
-fn decode_asserted_expr_value() -> decode.Decoder(AssertedExpr) {
+fn decode_asserted_expr_value() -> decode.Decoder(test_failure.AssertedExpr) {
   use start <- decode.optional_field("start", 0, decode.int)
   use end <- decode.optional_field("end", 0, decode.int)
   use kind <- decode.then(decode_expr_kind())
   decode.success(test_failure.AssertedExpr(start:, end:, kind:))
 }
 
-fn decode_expr_kind() -> decode.Decoder(ExprKind) {
+fn decode_expr_kind() -> decode.Decoder(test_failure.ExprKind) {
   use tag <- decode.optional_field("kind", "", decode.string)
   case tag {
     "literal" -> {