test-prof 1.6.3 → 1.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39f68f82427dfea9fb815614f6fce02fdfd7291fa1227e5c2a224f4c6483e091
-  data.tar.gz: cd76ddbed3548fa987b8828727e7ddd6f81639b39b8d06d5e8c41f7aa84fba10
+  metadata.gz: f0609d37fef8dc561de55a0f192414738049f53a4c47772fad6d6f1adaa596a1
+  data.tar.gz: b7bef544e98f887c86650268907adca116b30f87bf6d9c7c2a846ac6b2fe3649
 SHA512:
-  metadata.gz: 329db71243834a0641c490b3daaf77cfc5c352b1995c9b01dac49c0824619070d372e5eda7d64f76d97226087cfb2b9ad6d7e58823297e0e8ac53e5d74d82878
-  data.tar.gz: 72830459616db6692c3c58621457a459122aadc8609472f1a38b827025a19da11784b68aee86abc27d535ca1ecf474b18cd45d0c60c33b5490de3f4c0a314d18
+  metadata.gz: fcb4fc774acc4ac145817c00a7b8530151791481d32016375d54c5519c430dca9b2cdfe7064d1f05f633697b55ddbeefc6343b38c82e81944304481f24845ab7
+  data.tar.gz: e011f71777982864fd1dc5c1537872631eb3aeada674e6aa8e5be1e70648feee519eac9b02e1175f2b42117d07cd2fb1ff0e26c1fa0a2e4adc2b721cda780df9

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## master (unreleased)
 
+## 1.6.4 (2026-10-09)
+
+- Fix `RSpecDissect` writing bold escape sequences when the output is not a TTY. ([@meganemura][])
+
+- Fix `before_all` with parallel Minitest 6. ([@GabrielNagy][])
+
+- Add `EVENT_PROF_FORMAT` (`json`) support to EventProf along with the printers infrastructure (`Printers::Simple`, `Printers::Json`). ([@lHydra][])
+
+- Fix `before_all` Minitest `parallelize` patch rejecting Rails 7.0+ keyword arguments (`threshold:`, `parallelize_databases:`). ([@hnegishi][])
+
 ## 1.6.3 (2026-07-20)
 
 - Fix `before_all` firing N times in Minitest 6. ([@palkan][])
@@ -519,3 +529,5 @@ See [changelog](https://github.com/test-prof/test-prof/blob/v0.8.0/CHANGELOG.md)
 [@Rylan12]: https://github.com/Rylan12
 [@kddnewton]: https://github.com/kddnewton
 [@moznion]: https://github.com/moznion
+[@hnegishi]: https://github.com/hnegishi
+[@meganemura]: https://github.com/meganemura

data/README.md

@@ -37,12 +37,9 @@ TestProf toolbox aims to help you identify bottlenecks in your test suite. It co
   </a>
 </p>
 
-<p align="center">
-  <a href="https://evilmartians.com/?utm_source=test-prof">
-    <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg"
-         alt="Sponsored by Evil Martians" width="236" height="54">
-  </a>
-</p>
+<br/>
+
+<img src="https://cdn.evilmartians.com/badges/logo-no-label.svg" alt="Evil Martians logo" width="22" height="16" /> <b>TestProf</b> is built by <b><a href="https://evilmartians.com/">Evil Martians</a></b>, an American design and engineering consultancy for <b>developer tools, AI, and cybersecurity startups</b>.
 
 ## Who uses TestProf
 

data/lib/minitest/test_prof_plugin.rb

@@ -35,6 +35,9 @@ module Minitest # :nodoc:
     opts.on "--event-prof-per-example", TrueClass, "Includes examples metrics to results" do |flag|
       options[:per_example] = flag
     end
+    opts.on "--event-prof-format=FORMAT", "Defines output FORMAT for results" do |format|
+      options[:event_prof_format] = format
+    end
     opts.on "--factory-doctor", TrueClass, "Enable Factory Doctor for your examples" do |flag|
       options[:fdoc] = flag
     end

data/lib/test_prof/before_all/adapters/active_record.rb

@@ -10,47 +10,87 @@ module TestProf
         class << self
           if ::ActiveRecord::Base.connection.pool.respond_to?(:pin_connection!)
             def begin_transaction
-              subscribe!
+              # don't rely on connection_handler.connection_pool_list,
+              # track pinned pools ourselves
+              # see https://github.com/rails/rails/pull/58489
+              pinned_pools = []
+              pinned_pools_stack.push(pinned_pools)
+              subscribe! if pinned_pools_stack.size == 1
+
               ::ActiveRecord::Base.connection_handler.connection_pool_list(:writing).each do |pool|
-                pool.pin_connection!(true)
+                pin_pool!(pool)
+                pinned_pools << pool
               end
             end
 
             def rollback_transaction
-              ::ActiveRecord::Base.connection_handler.connection_pool_list(:writing).each do |pool|
-                pool.unpin_connection!
-              end
-              unsubscribe!
+              pinned_pools = pinned_pools_stack.pop
+              pinned_pools&.each { |pool| unpin_pool!(pool) }
+            ensure
+              unsubscribe! if pinned_pools_stack.empty?
             end
 
-            def subscribe!
-              Thread.current[:before_all_subscription_count] ||= 0
-              Thread.current[:before_all_subscription_count] += 1
+            def pinned_pools_stack
+              Thread.current[:before_all_pinned_pools_stack] ||= []
+            end
 
-              return unless Thread.current[:before_all_subscription_count] == 1
+            def subscribe!
+              # notifications are not Thread-pinned, so
+              # we must keep a reference to the current stack
+              stack = pinned_pools_stack
 
               Thread.current[:before_all_connection_subscriber] = ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
                 connection_name = payload[:connection_name] if payload.key?(:connection_name)
                 shard = payload[:shard] if payload.key?(:shard)
+                # Use the role of the established connection, not the current one
+                role = payload.fetch(:role, ::ActiveRecord::Base.current_role)
                 next unless connection_name
 
-                pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, shard: shard)
+                pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, role: role, shard: shard)
                 next unless pool && pool.role == :writing
 
-                pool.pin_connection!(true)
+                pinned_pools = stack.last
+                next if pinned_pools.nil? || pinned_pools.include?(pool)
+
+                pin_pool!(pool)
+                pinned_pools << pool
               end
             end
 
             def unsubscribe!
-              return unless Thread.current[:before_all_subscription_count]
-
-              Thread.current[:before_all_subscription_count] -= 1
-
-              return unless Thread.current[:before_all_subscription_count] == 0 && Thread.current[:before_all_connection_subscriber]
+              return unless Thread.current[:before_all_connection_subscriber]
 
               ActiveSupport::Notifications.unsubscribe(Thread.current[:before_all_connection_subscriber])
               Thread.current[:before_all_connection_subscriber] = nil
             end
+
+            # Rails 8.2+
+            if ::ActiveRecord.version >= Gem::Version.new("8.2.0.alpha")
+              def pin_pool!(pool)
+                pool.pin_connection!(true)
+                pool.lease_connection.begin_transaction(joinable: false, _lazy: false)
+              end
+
+              def unpin_pool!(pool)
+                connection = pool.lease_connection
+                if connection.transaction_open?
+                  connection.rollback_transaction
+                else
+                  warn "!!! before_all transaction has been already rollbacked and could work incorrectly"
+                  connection.reset!
+                end
+              ensure
+                pool.unpin_connection!
+              end
+            else
+              def pin_pool!(pool)
+                pool.pin_connection!(true)
+              end
+
+              def unpin_pool!(pool)
+                pool.unpin_connection!
+              end
+            end
           else
             def all_connections
               @all_connections ||= if ::ActiveRecord::Base.respond_to? :connects_to

data/lib/test_prof/event_prof/minitest.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "minitest/base_reporter"
-require "minitest/event_prof_formatter"
 
 module Minitest
   module TestProf
@@ -12,7 +11,6 @@ module Minitest
 
         log :info, "EventProf enabled (#{@profiler.events.join(", ")})"
 
-        @formatter = EventProfFormatter.new(@profiler)
         @current_group = nil
         @current_example = nil
       end
@@ -32,8 +30,7 @@ module Minitest
 
       def report
         @profiler.group_finished(@current_group)
-        result = @formatter.prepare_results
-        log :info, result
+        ::TestProf::EventProf.config.printer.dump(@profiler)
       end
 
       private
@@ -64,6 +61,7 @@ module Minitest
       def configure_profiler(options)
         ::TestProf::EventProf.configure do |config|
           config.event = options[:event]
+          config.format = options[:event_prof_format] if options[:event_prof_format]
           config.rank_by = options[:rank_by] if options[:rank_by]
           config.top_count = options[:top_count] if options[:top_count]
           config.per_example = options[:per_example] if options[:per_example]

data/lib/test_prof/event_prof/printers/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TestProf
+  module EventProf
+    module Printers
+      module Base
+        include TestProf::Logging
+
+        private
+
+        def describe_group(id)
+          id.is_a?(Hash) ? id[:name] : id.top_level_description
+        end
+
+        def describe_example(id)
+          id.is_a?(Hash) ? id[:name] : id.description
+        end
+
+        def locate(id)
+          id.is_a?(Hash) ? id[:location] : id.metadata[:location]
+        end
+
+        def time_percentage(time, total_time)
+          (time / total_time * 100).round(2)
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/event_prof/printers/json.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "test_prof/event_prof/printers/base"
+require "test_prof/ext/float_duration"
+
+module TestProf
+  module EventProf
+    module Printers
+      module Json # :nodoc: all
+        class << self
+          using TestProf::FloatDuration
+
+          include Base
+
+          def dump(profilers)
+            data = []
+            profilers.each { |profiler| data << convert_results(profiler) }
+
+            outpath = TestProf.artifact_path("event-prof.json")
+            File.write(outpath, data.to_json)
+
+            log :info, "EventProf results to JSON: #{outpath}"
+          end
+
+          private
+
+          def convert_results(profiler)
+            result = profiler.results
+
+            {
+              event: profiler.event,
+              total_time: profiler.total_time.duration,
+              total_count: profiler.total_count,
+              absolute_run_time: profiler.absolute_run_time.duration,
+              time_percentage: time_percentage(profiler.total_time, profiler.absolute_run_time),
+              rank_by: profiler.rank_by,
+              top_count: profiler.top_count,
+              groups: result[:groups].map { |group| convert_group(group) }
+            }.tap do |data|
+              next unless result[:examples]
+
+              data[:examples] = result[:examples].map { |example| convert_example(example) }
+            end
+          end
+
+          def convert_group(group)
+            {
+              description: describe_group(group[:id]),
+              location: locate(group[:id]),
+              time: group[:time].duration,
+              run_time: group[:run_time].duration,
+              time_percentage: time_percentage(group[:time], group[:run_time]),
+              count: group[:count],
+              examples: group[:examples]
+            }
+          end
+
+          def convert_example(example)
+            {
+              description: describe_example(example[:id]),
+              location: locate(example[:id]),
+              time: example[:time].duration,
+              run_time: example[:run_time].duration,
+              time_percentage: time_percentage(example[:time], example[:run_time]),
+              count: example[:count]
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/event_prof/printers/simple.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "test_prof/event_prof/printers/base"
+require "test_prof/ext/float_duration"
+require "test_prof/ext/string_truncate"
+
+module TestProf
+  module EventProf
+    module Printers
+      module Simple # :nodoc: all
+        class << self
+          using TestProf::FloatDuration
+          using TestProf::StringTruncate
+
+          include Base
+
+          def dump(profilers)
+            profilers.each { |profiler| dump_profiler(profiler) }
+          end
+
+          private
+
+          def dump_profiler(profiler)
+            result = profiler.results
+            time_percentage = time_percentage(profiler.total_time, profiler.absolute_run_time)
+
+            msgs = []
+
+            msgs <<
+              <<~MSG
+                EventProf results for #{profiler.event}
+
+                Total time: #{profiler.total_time.duration} of #{profiler.absolute_run_time.duration} (#{time_percentage}%)
+                Total events: #{profiler.total_count}
+
+                Top #{profiler.top_count} slowest suites (by #{profiler.rank_by}):
+
+              MSG
+
+            result[:groups].each do |group|
+              description = describe_group(group[:id])
+              location = locate(group[:id])
+              time = group[:time]
+              run_time = group[:run_time]
+              time_percentage = time_percentage(time, run_time)
+
+              msgs <<
+                <<~GROUP
+                  #{description.truncate} (#{location}) – #{time.duration} (#{group[:count]} / #{group[:examples]}) of #{run_time.duration} (#{time_percentage}%)
+                GROUP
+            end
+
+            if result[:examples]
+              msgs << "\nTop #{profiler.top_count} slowest tests (by #{profiler.rank_by}):\n\n"
+
+              result[:examples].each do |example|
+                description = describe_example(example[:id])
+                location = locate(example[:id])
+                time = example[:time]
+                run_time = example[:run_time]
+                time_percentage = time_percentage(time, run_time)
+
+                msgs <<
+                  <<~GROUP
+                    #{description.truncate} (#{location}) – #{time.duration} (#{example[:count]}) of #{run_time.duration} (#{time_percentage}%)
+                  GROUP
+              end
+            end
+
+            log :info, msgs.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/event_prof/rspec.rb

@@ -1,16 +1,10 @@
 # frozen_string_literal: true
 
-require "test_prof/ext/float_duration"
-require "test_prof/ext/string_truncate"
-
 module TestProf
   module EventProf
     class RSpecListener # :nodoc:
       include Logging
 
-      using FloatDuration
-      using StringTruncate
-
       NOTIFICATIONS = %i[
         example_group_started
         example_group_finished
@@ -43,59 +37,11 @@ module TestProf
       end
 
       def print
-        @profiler.each(&method(:report))
-      end
-
-      def report(profiler)
-        result = profiler.results
-        time_percentage = time_percentage(profiler.total_time, profiler.absolute_run_time)
-
-        msgs = []
-
-        msgs <<
-          <<~MSG
-            EventProf results for #{profiler.event}
-
-            Total time: #{profiler.total_time.duration} of #{profiler.absolute_run_time.duration} (#{time_percentage}%)
-            Total events: #{profiler.total_count}
+        EventProf.config.printer.dump(@profiler)
 
-            Top #{profiler.top_count} slowest suites (by #{profiler.rank_by}):
+        return unless EventProf.config.stamp?
 
-          MSG
-
-        result[:groups].each do |group|
-          description = group[:id].top_level_description
-          location = group[:id].metadata[:location]
-          time = group[:time]
-          run_time = group[:run_time]
-          time_percentage = time_percentage(time, run_time)
-
-          msgs <<
-            <<~GROUP
-              #{description.truncate} (#{location}) – #{time.duration} (#{group[:count]} / #{group[:examples]}) of #{run_time.duration} (#{time_percentage}%)
-            GROUP
-        end
-
-        if result[:examples]
-          msgs << "\nTop #{profiler.top_count} slowest tests (by #{profiler.rank_by}):\n\n"
-
-          result[:examples].each do |example|
-            description = example[:id].description
-            location = example[:id].metadata[:location]
-            time = example[:time]
-            run_time = example[:run_time]
-            time_percentage = time_percentage(time, run_time)
-
-            msgs <<
-              <<~GROUP
-                #{description.truncate} (#{location}) – #{time.duration} (#{example[:count]}) of #{run_time.duration} (#{time_percentage}%)
-              GROUP
-          end
-        end
-
-        log :info, msgs.join
-
-        stamp!(profiler) if EventProf.config.stamp?
+        @profiler.each { |profiler| stamp!(profiler) }
       end
 
       def stamp!(profiler)
@@ -130,10 +76,6 @@ module TestProf
 
         log :info, msgs.join
       end
-
-      def time_percentage(time, total_time)
-        (time / total_time * 100).round(2)
-      end
     end
   end
 end

data/lib/test_prof/event_prof.rb

@@ -2,6 +2,9 @@
 
 require "test_prof/rspec_stamp"
 require "test_prof/event_prof/profiler"
+require "test_prof/event_prof/printers/base"
+require "test_prof/event_prof/printers/simple"
+require "test_prof/event_prof/printers/json"
 require "test_prof/event_prof/instrumentations/active_support"
 require "test_prof/event_prof/monitor"
 require "test_prof/utils/sized_ordered_set"
@@ -34,7 +37,7 @@ module TestProf
       }.freeze
 
       attr_accessor :instrumenter, :top_count, :per_example,
-        :rank_by, :event
+        :rank_by, :event, :format
 
       def initialize
         @event = ENV["EVENT_PROF"]
@@ -42,6 +45,7 @@ module TestProf
         @top_count = (ENV["EVENT_PROF_TOP"] || 5).to_i
         @per_example = ENV["EVENT_PROF_EXAMPLES"] == "1"
         @rank_by = (ENV["EVENT_PROF_RANK"] || :time).to_sym
+        @format = ENV["EVENT_PROF_FORMAT"]
         @stamp = ENV["EVENT_PROF_STAMP"]
 
         RSpecStamp.config.tags = @stamp if stamp?
@@ -55,6 +59,13 @@ module TestProf
         per_example == true
       end
 
+      def printer
+        case format.to_s
+        when "json" then Printers::Json
+        else Printers::Simple
+        end
+      end
+
       def resolve_instrumenter
         return instrumenter if instrumenter.is_a?(Module)
 

data/lib/test_prof/recipes/minitest/before_all.rb

@@ -3,22 +3,13 @@
 require "test_prof/before_all"
 
 Minitest.singleton_class.prepend(Module.new do
-  attr_reader :previous_klass
+  attr_accessor :previous_klass
   @previous_klass = nil
+end)
 
-  # Minitest 6+
-  if Minitest::Runnable.method_defined?(:run_suite)
-    def run(klass, *rest)
-      return super unless klass.respond_to?(:parallelized) && klass.parallelized
-
-      if @previous_klass && @previous_klass != klass
-        @previous_klass.before_all_executor&.deactivate!
-      end
-      @previous_klass = klass
-
-      super
-    end
-  else
+# Minitest 5
+unless Minitest::Runnable.respond_to?(:run_suite)
+  Minitest.singleton_class.prepend(Module.new do
     def run_one_method(klass, *rest)
       return super unless klass.respond_to?(:parallelized) && klass.parallelized
 
@@ -29,8 +20,8 @@ Minitest.singleton_class.prepend(Module.new do
 
       super
     end
-  end
-end)
+  end)
+end
 
 module TestProf
   module BeforeAll
@@ -115,6 +106,24 @@ module TestProf
           base.extend ClassMethods
 
           base.cattr_accessor :parallelized
+          # Minitest 6+
+          if ::Minitest::Runnable.respond_to?(:run_suite)
+            base.prepend(Module.new do
+              def run(*)
+                klass = self.class
+                return super unless klass.parallelized
+
+                previous_klass = ::Minitest.previous_klass
+                if previous_klass && previous_klass != klass
+                  previous_klass.before_all_executor&.deactivate!
+                end
+                ::Minitest.previous_klass = klass
+
+                super
+              end
+            end)
+          end
+
           if base.respond_to?(:parallelize_teardown)
             base.parallelize_teardown do
               last_klass = ::Minitest.previous_klass
@@ -126,7 +135,7 @@ module TestProf
 
           if base.respond_to?(:parallelize)
             base.singleton_class.prepend(Module.new do
-              def parallelize(workers: :number_of_processors, with: :processes)
+              def parallelize(workers: :number_of_processors, with: :processes, **options)
                 # super.parallelize returns nil when no parallelization is set up
                 if super.nil?
                   return

data/lib/test_prof/rspec_dissect/collector.rb

@@ -32,7 +32,7 @@ module TestProf # :nodoc: all
       end
 
       def print_group_result(group)
-        "#{group[:desc].truncate} (#{group[:loc]}) – \e[1m#{group[:total_setup].duration}\e[22m " \
+        "#{group[:desc].truncate} (#{group[:loc]}) – #{bold(group[:total_setup].duration)} " \
         "of #{group[:total].duration} / #{group[:count]} " \
         "(before: #{(group[:total_setup] - group[:total_lazy_let]).duration}, " \
         "before let: #{group[:total_before_let].duration}, " \
@@ -53,6 +53,16 @@ module TestProf # :nodoc: all
 
         msgs.join
       end
+
+      private
+
+      # Follow the logger's color setting, so that a report written to a file
+      # or a pipe has no escape sequences in it
+      def bold(str)
+        return str unless TestProf.config.color?
+
+        "\e[1m#{str}\e[22m"
+      end
     end
   end
 end

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "1.6.3"
+  VERSION = "1.6.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.6.4
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -135,7 +135,6 @@ files:
 - config/default.yml
 - config/rubocop-rspec.yml
 - lib/minitest/base_reporter.rb
-- lib/minitest/event_prof_formatter.rb
 - lib/minitest/test_prof_plugin.rb
 - lib/rubocop/test_prof.rb
 - lib/rubocop/test_prof/cops/rspec/aggregate_examples.rb
@@ -167,6 +166,9 @@ files:
 - lib/test_prof/event_prof/instrumentations/active_support.rb
 - lib/test_prof/event_prof/minitest.rb
 - lib/test_prof/event_prof/monitor.rb
+- lib/test_prof/event_prof/printers/base.rb
+- lib/test_prof/event_prof/printers/json.rb
+- lib/test_prof/event_prof/printers/simple.rb
 - lib/test_prof/event_prof/profiler.rb
 - lib/test_prof/event_prof/rspec.rb
 - lib/test_prof/ext/active_record_refind.rb

data/lib/minitest/event_prof_formatter.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require "test_prof/ext/float_duration"
-require "test_prof/ext/string_truncate"
-
-module Minitest
-  module TestProf
-    class EventProfFormatter # :nodoc:
-      using ::TestProf::FloatDuration
-      using ::TestProf::StringTruncate
-
-      def initialize(profilers)
-        @profilers = profilers
-        @results = []
-      end
-
-      def prepare_results
-        @profilers.each do |profiler|
-          total_results(profiler)
-          by_groups(profiler)
-          by_examples(profiler)
-        end
-        @results.join
-      end
-
-      private
-
-      def total_results(profiler)
-        time_percentage = time_percentage(profiler.total_time, profiler.absolute_run_time)
-
-        @results <<
-          <<~MSG
-            EventProf results for #{profiler.event}
-
-            Total time: #{profiler.total_time.duration} of #{profiler.absolute_run_time.duration} (#{time_percentage}%)
-            Total events: #{profiler.total_count}
-
-            Top #{profiler.top_count} slowest suites (by #{profiler.rank_by}):
-
-          MSG
-      end
-
-      def by_groups(profiler)
-        result = profiler.results
-        groups = result[:groups]
-
-        groups.each do |group|
-          description = group[:id][:name]
-          location = group[:id][:location]
-          time = group[:time]
-          run_time = group[:run_time]
-          time_percentage = time_percentage(time, run_time)
-
-          @results <<
-            <<~GROUP
-              #{description.truncate} (#{location}) – #{time.duration} (#{group[:count]} / #{group[:examples]}) of #{run_time.duration} (#{time_percentage}%)
-            GROUP
-        end
-      end
-
-      def by_examples(profiler)
-        result = profiler.results
-        examples = result[:examples]
-
-        return unless examples
-        @results << "\nTop #{profiler.top_count} slowest tests (by #{profiler.rank_by}):\n\n"
-
-        examples.each do |example|
-          description = example[:id][:name]
-          location = example[:id][:location]
-          time = example[:time]
-          run_time = example[:run_time]
-          time_percentage = time_percentage(time, run_time)
-
-          @results <<
-            <<~GROUP
-              #{description.truncate} (#{location}) – #{time.duration} (#{example[:count]}) of #{run_time.duration} (#{time_percentage}%)
-            GROUP
-        end
-      end
-
-      def time_percentage(time, total_time)
-        (time / total_time * 100).round(2)
-      end
-    end
-  end
-end