tldr 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4be82f4551acdf8d4312b512a1c12d2a857cb1d1420b4eebc6d7a74632eecd19
-  data.tar.gz: 8f10cecb4d4701fb24f84c36ec78f6b91fe4b381bcf6c86f02f2743f93b61a1f
+  metadata.gz: 82e76ebc309cbf643c22244a1674aa3a7ae32578006ce05fac262aec15292bec
+  data.tar.gz: 99610ebabba0d069f3618f6fa7cf79793c44491c4764463283e304fe329c7247
 SHA512:
-  metadata.gz: 8262b1e6ee4fd4154d9c46d883d1d49b76026a3752b5d26a4ea520fa8b0c0b786019cb3c770b319bd22130c1f194883d02cefbb38b9f171a4571b91ab1793d5f
-  data.tar.gz: 125b89ee409f0080a61ceb00232464c455213223883ce10502742a90a825c0a208ed625e5608ecd585a26a900bc49dd8d6a1b49202a88684386c455d9eb313a0
+  metadata.gz: de39822a1208f86b69a45ac1185d2c6de22462282a6fa2f59054e84bfa55b135f61279ae3b9be2f61463557a2a04516397bd02083a6c2c8a26c8e627875a44d1
+  data.tar.gz: ae0c0ed4ec84f2969a0b223a668351ce475536121fb59e2b56a4fbd7be18be844d5fec3aaf3d5ebfd5cf37ddb6a0a02afeef1f0e1f2f975c7d2796d322ab0ccb

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.6.2]
+
+* Since TLDR runs fine on 3.1, reduce the gem requirement
+
+## [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

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/{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/planner.rb

@@ -2,6 +2,10 @@ require "pathname"
 
 class TLDR
   class Planner
+    def initialize
+      @strategizer = Strategizer.new
+    end
+
     def plan config
       $VERBOSE = config.warnings
       search_locations = PathUtil.expand_paths config.paths, globs: false
@@ -12,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(
@@ -29,6 +32,15 @@ class TLDR
         ),
         config
       )
+
+      strategy = @strategizer.strategize(
+        tests_to_run,
+        GROUPED_TESTS,
+        THREAD_UNSAFE_TESTS,
+        config
+      )
+
+      Plan.new tests_to_run, strategy
     end
 
     private
@@ -68,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
@@ -89,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

data/lib/tldr/reporters/default.rb

@@ -87,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"),
@@ -127,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,7 +55,8 @@ 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
+    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|

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/version.rb

@@ -1,3 +1,3 @@
 class TLDR
-  VERSION = "0.6.0"
+  VERSION = "0.6.2"
 end

data/lib/tldr.rb

@@ -5,8 +5,8 @@ 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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tldr
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Justin Searls
@@ -61,8 +61,8 @@ files:
 - 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
@@ -100,14 +100,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: TLDR will run your tests, but only for 1.8 seconds.