tldr 0.5.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32f7b9dbcf9e09433eef762eaafe19804643aa543ac2c0a9599303ea2e960f25
-  data.tar.gz: 789c07fb2db1fad39b234976999b575a1bea27c4796a4d062a373df11d3716e5
+  metadata.gz: 8e0c6abcfc7b58fc6de05591d61ceadfcbbed4867cfb140081f62877bb80d9a6
+  data.tar.gz: e62acff5d7e667214527d5bcafef6ba2540abbe4a187f441da07575919a34da0
 SHA512:
-  metadata.gz: 7975ec24ae3f080ed564666c5319928964c970794a740a21253551be1be9b945374394b2f860cdd8737151f8e21fdb0d592c126895dd02b91dd21c899824226a
-  data.tar.gz: b11f3c52624b63a7aa44eadd4f17aa662d134648d61eb55eb7124e7956d0b28f20a04545552f9af8710330ffa98c94e85cec87dc80715a532522ccdeb15a8b42
+  metadata.gz: 9c31d1f3fba81d133e2ef570b2252504cc67150d0729e56e0690fe5dbb8e3bd0512bec39e95a178eb12a8108fa92e56365fa981c3fc528ee3c845939237c347f
+  data.tar.gz: 3e35999424094dc072b6f2be670259e584dc14edf5621236a37efb0282c38c9ae434d63bd33fbe44b23f8fbf6f1b79fef801fb5f9375ff924d851c8063f63ba8

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.6.1]
+
+* Correctly report the number of test classes that run
+* Finish planning the test run before starting the clock on the timer (that's
+a millisecond or two in savings!)
+
+## [0.6.0]
+
+* When `dont_run_these_in_parallel!` and `run_these_together!` are called from a
+super class, gather subclasses' methods as well when the method is `nil`
+* Stop shelling out to `tldr` from our Rake task. Rescue `SystemExit` instead
+* Rename `Config#helper` to `Config#helper_paths`, which YAML config keys
+* Print Ruby warnings by default (disable with --no-warnings)
+
 ## [0.5.0]
 
 * Define your own Rake tasks with `TLDR::Task` and pass in a custom configuration

data/README.md

@@ -23,8 +23,8 @@ suite.
 
 Some stuff you might like:
 
-* A CLI that can run tests by line number(s) (e.g. `foo.rb:5 bar.rb:3:10`) and
-by names or patterns (e.g. `--name test_fail,test_error --name "/_\d/"`)
+* A CLI that can specify tests by line number(s) (e.g. `foo.rb:5 bar.rb:3:10`)
+and by names or patterns (e.g. `--name test_fail,test_error --name "/_\d/"`)
 * Everything is **parallel by default**, and seems pretty darn fast; TLDR
 also provides [several escape hatches to sequester tests that aren't thread-safe](#parallel-by-default-is-nice-in-theory-but-half-my-tests-are-failing-wat)
 * Surprisingly delightful color diff output when two things fail to equal one
@@ -112,8 +112,8 @@ Usage: tldr [options] some_tests/**/*.rb some/path.rb:13 ...
     -n, --name PATTERN               One or more names or /patterns/ of tests to run (like: foo_test, /test_foo.*/, Foo#foo_test)
         --exclude-name PATTERN       One or more names or /patterns/ NOT to run
         --exclude-path PATH          One or more paths NOT to run (like: foo.rb, "test/bar/**", baz.rb:3)
-        --helper HELPER              Path to a test helper to load before any tests (Default: "test/helper.rb")
-        --no-helper                  Don't try loading a test helper before the tests
+        --helper PATH                One or more paths to a helper that is required before any tests (Default: "test/helper.rb")
+        --no-helper                  Don't require any test helpers
         --prepend PATH               Prepend one or more paths to run before the rest (Default: most recently modified test)
         --no-prepend                 Don't prepend any tests before the rest of the suite
     -l, --load-path PATH             Add one or more paths to the $LOAD_PATH (Default: ["test"])
@@ -122,6 +122,7 @@ Usage: tldr [options] some_tests/**/*.rb some/path.rb:13 ...
         --no-dotfile                 Disable loading .tldr.yml dotfile
         --no-emoji                   Disable emoji in the output
     -v, --verbose                    Print stack traces for errors
+        --[no-]warnings              Print Ruby warnings (Default: true)
         --comment COMMENT            No-op comment, used internally for multi-line execution instructions
 ```
 
@@ -193,7 +194,7 @@ require "tldr/rake"
 
 TLDR::Task.new(name: :safe_tests, config: TLDR::Config.new(
   paths: FileList["safe/**/*_test.rb"],
-  helper: "safe/helper.rb",
+  helper_paths: ["safe/helper.rb"],
   load_paths: ["lib", "safe"]
 ))
 ```

data/Rakefile

@@ -6,6 +6,7 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "tests"
   t.libs << "lib"
+  t.warning = true
   t.test_files = FileList["tests/**/*_test.rb"]
 end
 

data/lib/tldr/argv_parser.rb

@@ -35,11 +35,12 @@ class TLDR
           options[:exclude_paths] += path
         end
 
-        opts.on "#{CONFLAGS[:helper]} HELPER", String, "Path to a test helper to load before any tests (Default: \"test/helper.rb\")" do |helper|
-          options[:helper] = helper
+        opts.on "#{CONFLAGS[:helper_paths]} PATH", Array, "One or more paths to a helper that is required before any tests (Default: \"test/helper.rb\")" do |path|
+          options[:helper_paths] ||= []
+          options[:helper_paths] += path
         end
 
-        opts.on CONFLAGS[:no_helper], "Don't try loading a test helper before the tests" do
+        opts.on CONFLAGS[:no_helper], "Don't require any test helpers" do
           options[:no_helper] = true
         end
 
@@ -77,6 +78,10 @@ class TLDR
           options[:verbose] = verbose
         end
 
+        opts.on CONFLAGS[:warnings], "Print Ruby warnings (Default: true)" do |warnings|
+          options[:warnings] = warnings
+        end
+
         opts.on "--comment COMMENT", String, "No-op comment, used internally for multi-line execution instructions" do
           # See "--comment" in lib/tldr/reporters/default.rb for an example of how this is used internally
         end

data/lib/tldr/class_util.rb

@@ -0,0 +1,15 @@
+class TLDR
+  module ClassUtil
+    def self.gather_descendants root_klass
+      root_klass.subclasses + root_klass.subclasses.flat_map { |subklass|
+        gather_descendants subklass
+      }
+    end
+
+    def self.gather_tests klass
+      klass.instance_methods.grep(/^test_/).sort.map { |method|
+        Test.new klass, method
+      }
+    end
+  end
+end

data/lib/tldr/{parallelizer.rb → executor.rb}

@@ -1,26 +1,20 @@
 class TLDR
-  class Parallelizer
+  class Executor
     def initialize
-      @strategizer = Strategizer.new
       @thread_pool = Concurrent::ThreadPoolExecutor.new(
         name: "tldr",
         auto_terminate: true
       )
     end
 
-    def parallelize all_tests, config, &blk
-      return run_in_sequence(all_tests, &blk) if all_tests.size < 2 || !config.parallel
-
-      strategy = @strategizer.strategize(
-        all_tests,
-        GROUPED_TESTS,
-        THREAD_UNSAFE_TESTS,
-        (config.no_prepend ? [] : config.prepend_paths)
-      )
-
-      run_in_sequence(strategy.prepend_thread_unsafe_tests, &blk) +
-        run_in_parallel(strategy.parallel_tests_and_groups, &blk) +
-        run_in_sequence(strategy.thread_unsafe_tests, &blk)
+    def execute plan, &blk
+      if plan.strategy.parallel?
+        run_in_sequence(plan.strategy.prepend_sequential_tests, &blk) +
+          run_in_parallel(plan.strategy.parallel_tests_and_groups, &blk) +
+          run_in_sequence(plan.strategy.append_sequential_tests, &blk)
+      else
+        run_in_sequence(plan.tests, &blk)
+      end
     end
 
     private

data/lib/tldr/path_util.rb

@@ -1,6 +1,8 @@
 class TLDR
   module PathUtil
-    def self.expand_search_locations path_strings
+    def self.expand_paths path_strings, globs: true
+      path_strings = expand_globs path_strings if globs
+
       path_strings.flat_map { |path_string|
         File.directory?(path_string) ? Dir["#{path_string}/**/*.rb"] : path_string
       }.flat_map { |path_string|

data/lib/tldr/planner.rb

@@ -2,8 +2,13 @@ require "pathname"
 
 class TLDR
   class Planner
+    def initialize
+      @strategizer = Strategizer.new
+    end
+
     def plan config
-      search_locations = PathUtil.expand_search_locations config.paths
+      $VERBOSE = config.warnings
+      search_locations = PathUtil.expand_paths config.paths, globs: false
 
       prepend_load_paths config
       require_test_helper config
@@ -11,8 +16,7 @@ class TLDR
 
       tests = gather_tests
       config.update_after_gathering_tests! tests
-
-      Plan.new prepend(
+      tests_to_run = prepend(
         shuffle(
           exclude_by_path(
             exclude_by_name(
@@ -28,21 +32,28 @@ class TLDR
         ),
         config
       )
+
+      strategy = @strategizer.strategize(
+        tests_to_run,
+        GROUPED_TESTS,
+        THREAD_UNSAFE_TESTS,
+        config
+      )
+
+      Plan.new tests_to_run, strategy
     end
 
     private
 
     def gather_tests
-      gather_descendants(TLDR).flat_map { |subklass|
-        subklass.instance_methods.grep(/^test_/).sort.map { |method|
-          Test.new subklass, method
-        }
+      ClassUtil.gather_descendants(TLDR).flat_map { |subklass|
+        ClassUtil.gather_tests(subklass)
       }
     end
 
     def prepend tests, config
       return tests if config.no_prepend
-      prepended_locations = PathUtil.expand_search_locations PathUtil.expand_globs config.prepend_paths
+      prepended_locations = PathUtil.expand_paths config.prepend_paths
       prepended, rest = tests.partition { |test|
         PathUtil.locations_include_test? prepended_locations, test
       }
@@ -54,7 +65,7 @@ class TLDR
     end
 
     def exclude_by_path tests, exclude_paths
-      excluded_locations = PathUtil.expand_search_locations PathUtil.expand_globs exclude_paths
+      excluded_locations = PathUtil.expand_paths exclude_paths
       return tests if excluded_locations.empty?
 
       tests.reject { |test|
@@ -69,7 +80,7 @@ class TLDR
 
       tests.reject { |test|
         name_excludes.any? { |filter|
-          filter === test.method.to_s || filter === "#{test.klass}##{test.method}"
+          filter === test.method_name.to_s || filter === "#{test.test_class}##{test.method_name}"
         }
       }
     end
@@ -90,7 +101,7 @@ class TLDR
 
       tests.select { |test|
         name_filters.any? { |filter|
-          filter === test.method.to_s || filter === "#{test.klass}##{test.method}"
+          filter === test.method_name.to_s || filter === "#{test.test_class}##{test.method_name}"
         }
       }
     end
@@ -102,8 +113,12 @@ class TLDR
     end
 
     def require_test_helper config
-      return if config.no_helper || config.helper.nil? || !File.exist?(config.helper)
-      require File.expand_path(config.helper, Dir.pwd)
+      return if config.no_helper || config.helper_paths.empty?
+      PathUtil.expand_paths(config.helper_paths).map(&:file).uniq.each do |helper_file|
+        next unless File.exist?(helper_file)
+
+        require helper_file
+      end
     end
 
     def require_tests search_locations
@@ -112,12 +127,6 @@ class TLDR
       end
     end
 
-    def gather_descendants root_klass
-      root_klass.subclasses + root_klass.subclasses.flat_map { |subklass|
-        gather_descendants subklass
-      }
-    end
-
     def expand_names_with_patterns names
       names.map { |name|
         if name.is_a?(String) && name =~ /^\/(.*)\/$/

data/lib/tldr/rake.rb

@@ -16,13 +16,17 @@ class TLDR
     def define name, task_config
       desc "Run #{name} tests (use TLDR_OPTS or .tldr.yml to configure)"
       task name do
-        cli_args = build_cli_args(task_config)
-        fail unless system "#{"bundle exec " if defined?(Bundler)}tldr #{cli_args}"
+        argv = Shellwords.shellwords(merge_env_opts(task_config).to_full_args)
+        begin
+          TLDR::Run.cli(argv)
+        rescue SystemExit => e
+          fail "TLDR task #{name} failed with status #{e.status}" unless e.status == 0
+        end
       end
     end
 
-    def build_cli_args task_config
-      config = if ENV["TLDR_OPTS"]
+    def merge_env_opts task_config
+      if ENV["TLDR_OPTS"]
         env_argv = Shellwords.shellwords(ENV["TLDR_OPTS"])
         opts_config = ArgvParser.new.parse(env_argv, {
           config_intended_for_merge_only: true
@@ -31,8 +35,6 @@ class TLDR
       else
         task_config
       end
-
-      config.to_full_args
     end
   end
 end

data/lib/tldr/reporters/default.rb

@@ -9,7 +9,8 @@ class TLDR
       def before_suite tests
         @suite_start_time = Process.clock_gettime Process::CLOCK_MONOTONIC, :microsecond
         @out.print <<~MSG
-          Command: #{tldr_command} #{@config.to_full_args}#{"\n#{@icons.seed} #{CONFLAGS[:seed]} #{@config.seed}" unless @config.seed_set_intentionally}
+          Command: #{tldr_command} #{@config.to_full_args}
+          #{@icons.seed} #{CONFLAGS[:seed]} #{@config.seed}
 
           #{@icons.run} Running:
 
@@ -86,7 +87,7 @@ class TLDR
         @out.print "Finished in #{duration}ms."
 
         @out.print "\n\n"
-        class_count = test_results.uniq { |result| result.test.class }.size
+        class_count = test_results.uniq { |result| result.test.test_class }.size
         test_count = test_results.size
         @out.print [
           plural(class_count, "test class", "test classes"),
@@ -126,7 +127,7 @@ class TLDR
       end
 
       def describe test, location = test.location
-        "#{test.klass}##{test.method} [#{location.locator}]"
+        "#{test.test_class}##{test.method_name} [#{location.locator}]"
       end
 
       def plural count, singular, plural = "#{singular}s"

data/lib/tldr/runner.rb

@@ -3,7 +3,7 @@ require "irb"
 class TLDR
   class Runner
     def initialize
-      @parallelizer = Parallelizer.new
+      @executor = Executor.new
       @wip = Concurrent::Array.new
       @results = Concurrent::Array.new
       @run_aborted = Concurrent::AtomicBoolean.new false
@@ -12,8 +12,8 @@ class TLDR
     def run config, plan
       @wip.clear
       @results.clear
-      reporter = config.reporter.new config
-      reporter.before_suite plan.tests
+      reporter = config.reporter.new(config)
+      reporter.before_suite(plan.tests)
 
       time_bomb = Thread.new {
         explode = proc do
@@ -34,34 +34,8 @@ class TLDR
         end
       }
 
-      results = @parallelizer.parallelize(plan.tests, config) { |test|
-        e = nil
-        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-        wip_test = WIPTest.new test, start_time
-        @wip << wip_test
-        runtime = time_it(start_time) do
-          instance = test.klass.new
-          instance.setup if instance.respond_to? :setup
-          if instance.respond_to? :around
-            did_run = false
-            instance.around {
-              did_run = true
-              instance.send(test.method)
-            }
-            raise Error, "#{test.klass}#around failed to yield or call the passed test block" unless did_run
-          else
-            instance.send(test.method)
-          end
-          instance.teardown if instance.respond_to? :teardown
-        rescue Skip, Failure, StandardError => e
-        end
-        TestResult.new(test, e, runtime).tap do |result|
-          next if @run_aborted.true?
-          @results << result
-          @wip.delete wip_test
-          reporter.after_test result
-          fail_fast reporter, plan, result if result.failing? && config.fail_fast
-        end
+      results = @executor.execute(plan) { |test|
+        run_test(test, config, plan, reporter)
       }.tap do
         time_bomb.kill
       end
@@ -74,6 +48,36 @@ class TLDR
 
     private
 
+    def run_test test, config, plan, reporter
+      e = nil
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+      wip_test = WIPTest.new test, start_time
+      @wip << wip_test
+      runtime = time_it(start_time) do
+        instance = test.test_class.new
+        instance.setup if instance.respond_to? :setup
+        if instance.respond_to? :around
+          did_run = false
+          instance.around {
+            did_run = true
+            instance.send(test.method_name)
+          }
+          raise Error, "#{test.test_class}#around failed to yield or call the passed test block" unless did_run
+        else
+          instance.send(test.method_name)
+        end
+        instance.teardown if instance.respond_to? :teardown
+      rescue Skip, Failure, StandardError => e
+      end
+      TestResult.new(test, e, runtime).tap do |result|
+        next if @run_aborted.true?
+        @results << result
+        @wip.delete wip_test
+        reporter.after_test result
+        fail_fast reporter, plan, result if result.failing? && config.fail_fast
+      end
+    end
+
     def fail_fast reporter, plan, fast_failed_result
       unless @run_aborted.true?
         @run_aborted.make_true

data/lib/tldr/strategizer.rb

@@ -1,6 +1,8 @@
 class TLDR
   class Strategizer
-    Strategy = Struct.new :prepend_thread_unsafe_tests, :parallel_tests_and_groups, :thread_unsafe_tests
+    Strategy = Struct.new :parallel?, :prepend_sequential_tests,
+      :parallel_tests_and_groups, :append_sequential_tests,
+      keyword_init: true
 
     # Combine all discovered test methods with any methods grouped by run_these_together!
     #
@@ -8,13 +10,15 @@ class TLDR
     #   - Map over tests to build out groups in order to retain shuffle order
     #     (group will run in position of first test in the group)
     #   - If a test is in multiple groups, only run it once
-    def strategize all_tests, run_these_together_groups, thread_unsafe_test_groups, prepend_paths
+    def strategize all_tests, run_these_together_groups, thread_unsafe_test_groups, config
+      return Strategy.new(parallel?: false) if run_sequentially?(all_tests, config)
+
       thread_unsafe_tests, thread_safe_tests = partition_unsafe(all_tests, thread_unsafe_test_groups)
-      prepend_thread_unsafe_tests, thread_unsafe_tests = partition_prepend(thread_unsafe_tests, prepend_paths)
+      prepend_sequential_tests, append_sequential_tests = partition_prepend(thread_unsafe_tests, config)
 
-      grouped_tests = prepare_run_together_groups run_these_together_groups, thread_safe_tests, thread_unsafe_tests
+      grouped_tests = prepare_run_together_groups run_these_together_groups, thread_safe_tests, append_sequential_tests
       already_included_groups = []
-      Strategy.new prepend_thread_unsafe_tests, thread_safe_tests.map { |test|
+      parallel_tests_and_groups = thread_safe_tests.map { |test|
         if (group = grouped_tests.find { |group| group.tests.include? test })
           if already_included_groups.include? group
             next
@@ -28,11 +32,21 @@ class TLDR
         else
           test
         end
-      }.compact, thread_unsafe_tests
+      }.compact
+      Strategy.new(
+        parallel?: true,
+        prepend_sequential_tests:,
+        parallel_tests_and_groups:,
+        append_sequential_tests:
+      )
     end
 
     private
 
+    def run_sequentially? all_tests, config
+      all_tests.size < 2 || !config.parallel
+    end
+
     def partition_unsafe tests, thread_unsafe_test_groups
       tests.partition { |test|
         thread_unsafe_test_groups.any? { |group| group.tests.include? test }
@@ -41,8 +55,9 @@ class TLDR
 
     # Sadly duplicative with Planner.rb, necessitating the extraction of PathUtil
     # Suboptimal, but we do indeed need to do this work in two places ¯\_(ツ)_/¯
-    def partition_prepend thread_unsafe_tests, prepend_paths
-      locations = PathUtil.expand_search_locations PathUtil.expand_globs prepend_paths
+    def partition_prepend thread_unsafe_tests, config
+      prepend_paths = config.no_prepend ? [] : config.prepend_paths
+      locations = PathUtil.expand_paths prepend_paths
 
       thread_unsafe_tests.partition { |test|
         PathUtil.locations_include_test? locations, test

data/lib/tldr/value/config.rb

@@ -4,7 +4,7 @@ class TLDR
     no_helper: "--no-helper",
     verbose: "--verbose",
     reporter: "--reporter",
-    helper: "--helper",
+    helper_paths: "--helper",
     load_paths: "--load-path",
     parallel: "--[no-]parallel",
     names: "--name",
@@ -16,19 +16,22 @@ class TLDR
     exclude_names: "--exclude-name",
     base_path: "--base-path",
     no_dotfile: "--no-dotfile",
+    warnings: "--[no-]warnings",
     paths: nil
   }.freeze
 
-  PATH_FLAGS = [:paths, :helper, :load_paths, :prepend_paths, :exclude_paths].freeze
+  PATH_FLAGS = [:paths, :helper_paths, :load_paths, :prepend_paths, :exclude_paths].freeze
   MOST_RECENTLY_MODIFIED_TAG = "MOST_RECENTLY_MODIFIED".freeze
-
-  Config = Struct.new :paths, :seed, :no_helper, :verbose, :reporter,
-    :helper, :load_paths, :parallel, :names, :fail_fast, :no_emoji,
+  CONFIG_ATTRIBUTES = [
+    :paths, :seed, :no_helper, :verbose, :reporter,
+    :helper_paths, :load_paths, :parallel, :names, :fail_fast, :no_emoji,
     :prepend_paths, :no_prepend, :exclude_paths, :exclude_names, :base_path,
-    :no_dotfile,
+    :no_dotfile, :warnings,
     # Internal properties
-    :config_intended_for_merge_only, :seed_set_intentionally, :cli_defaults,
-    keyword_init: true do
+    :config_intended_for_merge_only, :seed_set_intentionally, :cli_defaults
+  ].freeze
+
+  Config = Struct.new(*CONFIG_ATTRIBUTES, keyword_init: true) do
     def initialize(**args)
       unless args[:config_intended_for_merge_only]
         change_working_directory_because_i_am_bad_and_i_should_feel_bad!(args[:base_path])
@@ -60,20 +63,21 @@ class TLDR
         no_prepend: false,
         exclude_paths: [],
         exclude_names: [],
-        base_path: nil
+        base_path: nil,
+        warnings: true
       }
 
       if cli_defaults
         common.merge(
           paths: Dir["test/**/*_test.rb", "test/**/test_*.rb"],
-          helper: "test/helper.rb",
+          helper_paths: ["test/helper.rb"],
           load_paths: ["test"],
           prepend_paths: [MOST_RECENTLY_MODIFIED_TAG]
         )
       else
         common.merge(
           paths: [],
-          helper: nil,
+          helper_paths: [],
           load_paths: [],
           prepend_paths: []
         )
@@ -92,17 +96,17 @@ class TLDR
       defaults = Config.build_defaults(cli_defaults: merged_args[:cli_defaults])
 
       # Arrays
-      [:paths, :load_paths, :names, :prepend_paths, :exclude_paths, :exclude_names].each do |key|
+      [:paths, :helper_paths, :load_paths, :names, :prepend_paths, :exclude_paths, :exclude_names].each do |key|
         merged_args[key] = defaults[key] if merged_args[key].nil? || merged_args[key].empty?
       end
 
       # Booleans
-      [:no_helper, :verbose, :fail_fast, :no_emoji, :no_prepend].each do |key|
+      [:no_helper, :verbose, :fail_fast, :no_emoji, :no_prepend, :warnings].each do |key|
         merged_args[key] = defaults[key] if merged_args[key].nil?
       end
 
       # Values
-      [:seed, :reporter, :helper].each do |key|
+      [:seed, :reporter].each do |key|
         merged_args[key] ||= defaults[key]
       end
 
@@ -166,7 +170,7 @@ class TLDR
             # Don't print prepended tests if they're disabled
             next
           end
-        elsif key == :helper && no_helper
+        elsif key == :helper_paths && no_helper
           # Don't print the helper if it's disabled
           next
         elsif key == :parallel
@@ -176,6 +180,8 @@ class TLDR
             "--parallel"
           end
           next val
+        elsif key == :warnings && defaults[:warnings] != self[:warnings]
+          next warnings ? "--warnings" : "--no-warnings"
         end
 
         if defaults[key] == self[key]
@@ -231,6 +237,9 @@ class TLDR
       if dotfile_args.key?(:reporter)
         dotfile_args[:reporter] = Kernel.const_get(dotfile_args[:reporter])
       end
+      if (invalid_args = dotfile_args.except(*CONFIG_ATTRIBUTES)).any?
+        raise Error, "Invalid keys in .tldr.yml file: #{invalid_args.keys.join(", ")}"
+      end
 
       dotfile_args.merge(args)
     end

data/lib/tldr/value/plan.rb

@@ -1,3 +1,3 @@
 class TLDR
-  Plan = Struct.new :tests
+  Plan = Struct.new :tests, :strategy
 end

data/lib/tldr/value/test.rb

@@ -1,17 +1,17 @@
 class TLDR
-  Test = Struct.new :klass, :method do
+  Test = Struct.new :test_class, :method_name do
     attr_reader :file, :line, :location
 
     def initialize(*args)
       super
-      @file, @line = SorbetCompatibility.unwrap_method(klass.instance_method(method)).source_location
+      @file, @line = SorbetCompatibility.unwrap_method(test_class.instance_method(method_name)).source_location
       @location = Location.new file, line
     end
 
     # Memoizing at call time, because re-parsing isn't free and isn't usually necessary
     def end_line
       @end_line ||= begin
-        test_method = SorbetCompatibility.unwrap_method klass.instance_method(method)
+        test_method = SorbetCompatibility.unwrap_method test_class.instance_method(method_name)
         RubyVM::AbstractSyntaxTree.of(test_method).last_lineno
       end
     end

data/lib/tldr/value/test_group.rb

@@ -6,8 +6,8 @@ class TLDR
       @tests ||= configuration.flat_map { |(klass, method)|
         klass = Kernel.const_get(klass) if klass.is_a? String
         if method.nil?
-          klass.instance_methods.grep(/^test_/).sort.map { |method|
-            Test.new klass, method
+          ([klass] + ClassUtil.gather_descendants(klass)).flat_map { |klass|
+            ClassUtil.gather_tests(klass)
           }
         else
           Test.new klass, method

data/lib/tldr/version.rb

@@ -1,3 +1,3 @@
 class TLDR
-  VERSION = "0.5.0"
+  VERSION = "0.6.1"
 end

data/lib/tldr.rb

@@ -3,9 +3,10 @@ require "concurrent-ruby"
 require_relative "tldr/argv_parser"
 require_relative "tldr/assertions"
 require_relative "tldr/backtrace_filter"
+require_relative "tldr/class_util"
 require_relative "tldr/error"
+require_relative "tldr/executor"
 require_relative "tldr/parallel_controls"
-require_relative "tldr/parallelizer"
 require_relative "tldr/path_util"
 require_relative "tldr/planner"
 require_relative "tldr/reporters"
@@ -40,6 +41,8 @@ class TLDR
     def self.at_exit! config = Config.new
       # Ignore at_exit when running tldr CLI, since that will run any tests
       return if $PROGRAM_NAME.end_with? "tldr"
+      # Also ignore if we're running from within our rake task
+      return if caller.any? { |line| line.include? "lib/tldr/rake.rb" }
       # Ignore at_exit when we've already registered an at_exit hook
       return if @@at_exit_registered
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tldr
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Justin Searls
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-28 00:00:00.000000000 Z
+date: 2023-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: super_diff
@@ -59,9 +59,10 @@ files:
 - lib/tldr/assertions.rb
 - lib/tldr/assertions/minitest_compatibility.rb
 - lib/tldr/backtrace_filter.rb
+- lib/tldr/class_util.rb
 - lib/tldr/error.rb
+- lib/tldr/executor.rb
 - lib/tldr/parallel_controls.rb
-- lib/tldr/parallelizer.rb
 - lib/tldr/path_util.rb
 - lib/tldr/planner.rb
 - lib/tldr/rake.rb
@@ -106,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.17
 signing_key:
 specification_version: 4
 summary: TLDR will run your tests, but only for 1.8 seconds.