minitest-heat 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a8979e12c498f8e4d98e6988356639ab3601b04f1ab38da7af6de1cc6ef8a16
-  data.tar.gz: b8e7a5ec05630043cd50ecfbfa4e42dcf0c53b2984b95cb971ff806c2e8863f8
+  metadata.gz: 7e33245f206aa23bcbad541459db13fb8f6f088df51777850bb1276369dc0b3b
+  data.tar.gz: f66fd4f6ba49d1f80be0f97e0d54fd5fa5a2f4fa2063a57f20d9f46520d17ed2
 SHA512:
-  metadata.gz: 1df9dc10973d664bdcf0e1690e44c98907f1b59056e7948f16f5bc9d97a4a9b8d989dfebc73d0ad4a88ce35b1253614d340ebd941c451ce12b3be89dad58aabd
-  data.tar.gz: ff6a30b6e5e37f7efce044307a2f3265c1332654d62270571223392913d85566982bcf11add206eca60c58c58d3adf87e46010714591487a15af882ad7996def
+  metadata.gz: 24897c2218d77cae17eba80b0e28f24df8f051d13f3f2cddeb47ffabb4730a19b45601f34119749f7fa3d7828fbe617313821d6939cf41653e6559e91bf74526
+  data.tar.gz: 38b9e2b060ba864243e384ef260bfb9f771b607bc2786668d462abee84142d5505f3de63182e8238e94bc8ba01932f991125a4db1fcceb4252d764afcc7a62f8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    minitest-heat (0.0.6)
+    minitest-heat (0.0.7)
       minitest
 
 GEM

data/lib/minitest/heat/issue.rb

@@ -20,7 +20,7 @@ module Minitest
       attr_reader :result, :location, :failure
 
       def_delegators :@result, :passed?, :error?, :skipped?
-      def_delegators :@location, :backtrace
+      def_delegators :@location, :backtrace, :test_definition_line, :test_failure_line
 
       def initialize(result)
         @result = result
@@ -34,7 +34,7 @@ module Minitest
       #
       # @return [String] the pathname for the file relative to the present working directory
       def short_location
-        location.to_s.delete_prefix(Dir.pwd)
+        location.to_s.delete_prefix("#{Dir.pwd}/")
       end
 
       # Converts an issue to the key attributes for recording a 'hit'

data/lib/minitest/heat/output/backtrace.rb

@@ -26,7 +26,7 @@ module Minitest
             parts = [
               indentation_token,
               path_token(backtrace_entry),
-              file_and_line_number_token(backtrace_entry),
+              *file_and_line_number_tokens(backtrace_entry),
               source_code_line_token(backtrace_entry.source_code)
             ]
 
@@ -52,7 +52,7 @@ module Minitest
         # ...it's smart about exceptions that were raised outside of the project?
         # ...it's smart about highlighting lines of code differently based on whether it's source code, test code, or external code?
         def backtrace_entries
-          project_entries
+          all_entries
         end
 
         private
@@ -92,16 +92,16 @@ module Minitest
           [:muted, path]
         end
 
-        def file_and_line_number_token(backtrace_entry)
-          [:default, "#{backtrace_entry.file}:#{backtrace_entry.line_number}"]
+        def file_and_line_number_tokens(backtrace_entry)
+          [[:default, backtrace_entry.file], [:muted, ':'], [:default, backtrace_entry.line_number]]
         end
 
         def source_code_line_token(source_code)
-          [:muted, " `#{source_code.line.strip}`"]
+          [:muted, " #{Output::SYMBOLS[:arrow]} `#{source_code.line.strip}`"]
         end
 
         def file_freshness(_line)
-          [:bold, ' < Most Recently Modified']
+          [:default, " #{Output::SYMBOLS[:middot]} Most Recently Modified File"]
         end
 
         # The number of spaces each line of code should be indented. Currently defaults to 2 in

data/lib/minitest/heat/output/issue.rb

@@ -4,11 +4,6 @@ module Minitest
   module Heat
     class Output
       class Issue
-        SHARED_SYMBOLS = {
-          spacer: ' · ',
-          arrow: ' > '
-        }.freeze
-
         attr_accessor :issue
 
         def initialize(issue)
@@ -31,6 +26,8 @@ module Minitest
         def error_tokens
           [
             headline_tokens,
+            test_location_tokens,
+            location_tokens,
             summary_tokens,
             *backtrace_tokens,
             newline_tokens
@@ -40,6 +37,7 @@ module Minitest
         def broken_tokens
           [
             headline_tokens,
+            test_location_tokens,
             summary_tokens,
             *backtrace_tokens,
             newline_tokens
@@ -49,9 +47,8 @@ module Minitest
         def failure_tokens
           [
             headline_tokens,
+            test_location_tokens,
             summary_tokens,
-            location_tokens,
-            *source_tokens,
             newline_tokens
           ]
         end
@@ -59,7 +56,7 @@ module Minitest
         def skipped_tokens
           [
             headline_tokens,
-            summary_tokens,
+            test_location_tokens,
             newline_tokens
           ]
         end
@@ -67,7 +64,7 @@ module Minitest
         def painful_tokens
           [
             headline_tokens,
-            slowness_tokens,
+            slowness_summary_tokens,
             newline_tokens
           ]
         end
@@ -75,17 +72,17 @@ module Minitest
         def slow_tokens
           [
             headline_tokens,
-            slowness_tokens,
+            slowness_summary_tokens,
             newline_tokens
           ]
         end
 
         def headline_tokens
-          [[issue.type, issue.label], [:muted, spacer], [:default, issue.test_name], [:muted, spacer], [:muted, issue.test_class]]
+          [[issue.type, issue.label], spacer_token, [:default, issue.test_name]]
         end
 
-        def summary_tokens
-          [[:italicized, issue.summary]]
+        def test_name_and_class_tokens
+          [[:default, issue.test_class], *test_location_tokens ]
         end
 
         def backtrace_tokens
@@ -94,34 +91,88 @@ module Minitest
           backtrace.tokens
         end
 
+        def test_location_tokens
+          [[:default, test_file_short_location], [:muted, ':'], [:default, issue.test_definition_line], arrow_token, [:default, issue.test_failure_line], [:muted, test_line_source]]
+        end
+
         def location_tokens
-          [[:muted, issue.short_location]]
+          [[:default, most_relevant_short_location], [:muted, ':'], [:default, issue.location.most_relevant_failure_line], [:muted, most_relevant_line_source]]
         end
 
         def source_tokens
           filename    = issue.location.project_file
           line_number = issue.location.project_failure_line
 
-          source_code = ::Minitest::Heat::Output::SourceCode.new(filename, line_number)
+          # source_code = ::Minitest::Heat::Output::SourceCode.new(filename, line_number, max_line_count: 1)
+          # source_code.tokens
 
-          source_code.tokens
+          source = Minitest::Heat::Source.new(filename, line_number: line_number)
+          [[:muted, " #{Output::SYMBOLS[:arrow]} `#{source.line.strip}`"]]
         end
 
-        def slowness_tokens
-          [[:bold, issue.slowness], [:muted, spacer], [:default, issue.short_location] ]
+        def summary_tokens
+          [[:italicized, issue.summary.delete_suffix("---------------")]]
+        end
+
+        def slowness_summary_tokens
+          [[:bold, issue.slowness], spacer_token, [:default, issue.short_location]]
         end
 
         def newline_tokens
           []
         end
 
-        def spacer
-          SHARED_SYMBOLS[:spacer]
+        def most_relevant_short_location
+          issue.location.most_relevant_file.to_s.delete_prefix("#{Dir.pwd}/")
         end
 
-        def arrow
-          SHARED_SYMBOLS[:arrow]
+        def test_file_short_location
+          issue.location.test_file.to_s.delete_prefix("#{Dir.pwd}/")
         end
+
+        def most_relevant_line_source
+          filename    = issue.location.project_file
+          line_number = issue.location.project_failure_line
+
+          source = Minitest::Heat::Source.new(filename, line_number: line_number)
+          "\n  #{source.line.strip}"
+        end
+
+        def test_line_source
+          filename    = issue.location.test_file
+          line_number = issue.location.test_failure_line
+
+          source = Minitest::Heat::Source.new(filename, line_number: line_number)
+          "\n  #{source.line.strip}"
+        end
+
+
+        # def failure_summary_tokens
+        #   return unless issue_summary_lines.any?
+
+        #   # Sometimes, the exception message is multiple lines, so this adjusts the lines to
+        #   # visually group them together a bit
+        #   if issue_summary_lines.one?
+        #     [[[:italicized, issue_summary_lines.first]]]
+        #   else
+        #     issue_summary_lines.map do |line|
+        #       [Output::TOKENS[:muted_lead], [:italicized, line]]
+        #     end
+        #   end
+        # end
+
+        # def issue_summary_lines
+        #   @issue_summary_lines ||= issue.summary.split("\n")
+        # end
+
+        def spacer_token
+          Output::TOKENS[:spacer]
+        end
+
+        def arrow_token
+          Output::TOKENS[:muted_arrow]
+        end
+
       end
     end
   end

data/lib/minitest/heat/output/results.rb

@@ -6,19 +6,25 @@ module Minitest
       class Results
         extend Forwardable
 
-        attr_accessor :results
+        attr_accessor :results, :timer
 
-        def_delegators :@results, :errors, :brokens, :failures, :skips, :painfuls, :slows, :problems?, :slows?
+        def_delegators :@results, :issues, :errors, :brokens, :failures, :skips, :painfuls, :slows, :problems?
 
-        def initialize(results)
+        def initialize(results, timer)
           @results = results
+          @timer = timer
           @tokens = []
         end
 
         def tokens
+          # Only show the issue type counts if there are issues
           @tokens << [*issue_counts_tokens] if issue_counts_tokens&.any?
-          @tokens << [assertions_performance_token, tests_performance_token, timing_token]
-          @tokens << [assertions_count_token, test_count_token]
+
+          @tokens << [
+            timing_token, spacer_token,
+            test_count_token, tests_performance_token, join_token,
+            assertions_count_token, assertions_performance_token
+          ]
 
           @tokens
         end
@@ -33,7 +39,7 @@ module Minitest
         end
 
         def issue_counts_tokens
-          return unless problems? || slows?
+          return unless issues.any?
 
           counts = [
             error_count_token,
@@ -45,10 +51,10 @@ module Minitest
           ].compact
 
           # # Create an array of separator tokens one less than the total number of issue count tokens
-          separator_tokens = Array.new(counts.size, separator_token)
+          spacer_tokens = Array.new(counts.size, spacer_token)
 
           counts_with_separators = counts
-                                   .zip(separator_tokens) # Add separators between the counts
+                                   .zip(spacer_tokens) # Add separators between the counts
                                    .flatten(1) # Flatten the zipped separators, but no more
 
           counts_with_separators.pop # Remove the final trailing zipped separator that's not needed
@@ -74,33 +80,33 @@ module Minitest
         end
 
         def painful_count_token
-          style = problems? ? :muted : :painful
+          style = problems? || skips.any? ? :muted : :painful
           issue_count_token(style, painfuls, name: 'Painfully Slow')
         end
 
         def slow_count_token
-          style = problems? ? :muted : :slow
+          style = problems? || skips.any? ? :muted : :slow
           issue_count_token(style, slows, name: 'Slow')
         end
 
-        def assertions_performance_token
-          [:bold, "#{results.assertions_per_second} assertions/s"]
+        def test_count_token
+          [:default, "#{pluralize(timer.test_count, 'test')}"]
         end
 
         def tests_performance_token
-          [:default, " and #{results.tests_per_second} tests/s"]
+          [:default, " (#{timer.tests_per_second}/s)"]
         end
 
-        def timing_token
-          [:default, " in #{results.total_time.round(2)}s"]
+        def assertions_count_token
+          [:default, "#{pluralize(timer.assertion_count, 'assertion')}"]
         end
 
-        def assertions_count_token
-          [:muted, pluralize(results.assertion_count, 'Assertion')]
+        def assertions_performance_token
+          [:default, " (#{timer.assertions_per_second}/s)"]
         end
 
-        def test_count_token
-          [:muted, " across #{pluralize(results.test_count, 'Test')}"]
+        def timing_token
+          [:bold, "#{timer.total_time.round(2)}s"]
         end
 
         def issue_count_token(type, collection, name: type.capitalize)
@@ -109,8 +115,12 @@ module Minitest
           [type, pluralize(collection.size, name)]
         end
 
-        def separator_token
-          [:muted, ' · ']
+        def spacer_token
+          Output::TOKENS[:spacer]
+        end
+
+        def join_token
+          [:default, ' with ']
         end
       end
     end

data/lib/minitest/heat/output.rb

@@ -12,6 +12,18 @@ module Minitest
   module Heat
     # Friendly API for printing nicely-formatted output to the console
     class Output
+      SYMBOLS = {
+        middot: '·',
+        arrow: '➜',
+        lead: '|',
+      }.freeze
+
+      TOKENS = {
+        spacer:      [:muted, " #{SYMBOLS[:middot]} "],
+        muted_arrow: [:muted, " #{SYMBOLS[:arrow]} "],
+        muted_lead:  [:muted, "#{SYMBOLS[:lead]} "],
+      }
+
       attr_reader :stream
 
       def initialize(stream = $stdout)
@@ -38,9 +50,9 @@ module Minitest
         print_token Minitest::Heat::Output::Marker.new(issue_type).token
       end
 
-      def compact_summary(results)
+      def compact_summary(results, timer)
         newline
-        print_tokens ::Minitest::Heat::Output::Results.new(results).tokens
+        print_tokens ::Minitest::Heat::Output::Results.new(results, timer).tokens
       end
 
       def heat_map(map)

data/lib/minitest/heat/results.rb

@@ -4,119 +4,48 @@ module Minitest
   module Heat
     # A collection of test failures
     class Results
-      attr_reader :test_count,
-                  :assertion_count,
-                  :success_count,
-                  :issues,
-                  :start_time,
-                  :stop_time
+      attr_reader :issues
 
       def initialize
-        @test_count = 0
-        @assertion_count = 0
-        @success_count = 0
-        @issues = {
-          error: [],
-          broken: [],
-          failure: [],
-          skipped: [],
-          painful: [],
-          slow: []
-        }
-        @start_time = nil
-        @stop_time = nil
+        @issues = []
       end
 
-      def start_timer!
-        @start_time = Minitest.clock_time
-      end
-
-      def stop_timer!
-        @stop_time = Minitest.clock_time
-      end
-
-      def total_time
-        delta = @stop_time - @start_time
-
-        # Don't return 0
-        delta.zero? ? 0.1 : delta
-      end
-
-      def tests_per_second
-        (assertion_count / total_time).round(2)
-      end
-
-      def assertions_per_second
-        (assertion_count / total_time).round(2)
+      def record(issue)
+        @issues << issue
       end
 
       def problems?
-        errors? || brokens? || failures? || skips?
+        errors.any? || brokens.any? || failures.any?
       end
 
       def errors
-        issues.fetch(:error) { [] }
+        @errors ||= select_issues(:error)
       end
 
       def brokens
-        issues.fetch(:broken) { [] }
+        @brokens ||= select_issues(:broken)
       end
 
       def failures
-        issues.fetch(:failure) { [] }
+        @failures ||= select_issues(:failure)
       end
 
       def skips
-        issues.fetch(:skipped) { [] }
+        @skips ||= select_issues(:skipped)
       end
 
       def painfuls
-        issues
-          .fetch(:painful) { [] }
-          .sort_by(&:time)
-          .reverse
-          .take(5)
+        @painfuls ||= select_issues(:painful).sort_by(&:time).reverse
       end
 
       def slows
-        issues
-          .fetch(:slow) { [] }
-          .sort_by(&:time)
-          .reverse
-          .take(5)
-      end
-
-      def errors?
-        errors.any?
+        @slows ||= select_issues(:slow).sort_by(&:time).reverse
       end
 
-      def brokens?
-        brokens.any?
-      end
-
-      def failures?
-        failures.any?
-      end
-
-      def skips?
-        skips.any?
-      end
-
-      def painfuls?
-        painfuls.any?
-      end
-
-      def slows?
-        slows.any?
-      end
-
-      def record(issue)
-        @test_count += 1
-        @assertion_count += issue.result.assertions
-        @success_count += 1 if issue.result.passed?
+      private
 
-        @issues[issue.type] ||= []
-        @issues[issue.type] << issue
+      def select_issues(issue_type)
+        issues.select { |issue| issue.type == issue_type }
       end
     end
   end

data/lib/minitest/heat/timer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    # Provides a timer to keep track of the full test suite duration and provide convenient methods
+    #   for calculating tests/second and assertions/second
+    class Timer
+      attr_reader :test_count, :assertion_count, :start_time, :stop_time
+
+      # Creates an instance of a timer to be used for the duration of a test suite run
+      #
+      # @return [self]
+      def initialize
+        @test_count = 0
+        @assertion_count = 0
+
+        @start_time = nil
+        @stop_time = nil
+      end
+
+      # Records the start time for the full test suite using `Minitest.clock_time`
+      #
+      # @return [Float] the Minitest.clock_time
+      def start!
+        @start_time = Minitest.clock_time
+      end
+
+      # Records the stop time for the full test suite using `Minitest.clock_time`
+      #
+      # @return [Float] the Minitest.clock_time
+      def stop!
+        @stop_time = Minitest.clock_time
+      end
+
+      # Calculates the total time take for the full test suite to run while ensuring it never
+      #   returns a zero that would be problematic as a denomitor in calculating average times
+      #
+      # @return [Float] the clocktime duration of the test suite run in seconds
+      def total_time
+        # Don't return 0. The time can end up being 0 for a new or realy fast test suite, and
+        # dividing by 0 doesn't go well when determining average time, so this ensures it uses a
+        # close-enough-but-not-zero value.
+        delta.zero? ? 0.01 : delta
+      end
+
+      # Records the test and assertion counts for a given test outcome
+      # @param count [Integer] the number of assertions from the test
+      #
+      # @return [void]
+      def increment_counts(count)
+        @test_count += 1
+        @assertion_count += count
+      end
+
+      # Provides a nice rounded answer for about how many tests were completed per second
+      #
+      # @return [Float] the average number of tests completed per second
+      def tests_per_second
+        (test_count / total_time).round(2)
+      end
+
+      # Provides a nice rounded answer for about how many assertions were completed per second
+      #
+      # @return [Float] the average number of assertions completed per second
+      def assertions_per_second
+        (assertion_count / total_time).round(2)
+      end
+
+      private
+
+      # The total time the test suite was running.
+      #
+      # @return [Float] the time in seconds elapsed between starting the timer and stopping it
+      def delta
+        return 0 unless start_time && stop_time
+
+        stop_time - start_time
+      end
+    end
+  end
+end

data/lib/minitest/heat/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Heat
-    VERSION = '0.0.6'
+    VERSION = '0.0.7'
   end
 end

data/lib/minitest/heat.rb

@@ -9,6 +9,7 @@ require_relative 'heat/map'
 require_relative 'heat/output'
 require_relative 'heat/results'
 require_relative 'heat/source'
+require_relative 'heat/timer'
 require_relative 'heat/version'
 
 module Minitest

data/lib/minitest/heat_reporter.rb

@@ -31,12 +31,14 @@ module Minitest
   class HeatReporter < AbstractReporter
     attr_reader :output,
                 :options,
+                :timer,
                 :results,
                 :map
 
     def initialize(io = $stdout, options = {})
       @options = options
 
+      @timer =    Heat::Timer.new
       @results =  Heat::Results.new
       @map =      Heat::Map.new
       @output =   Heat::Output.new(io)
@@ -44,7 +46,7 @@ module Minitest
 
     # Starts reporting on the run.
     def start
-      results.start_timer!
+      timer.start!
 
       # A couple of blank lines to create some breathing room
       output.newline
@@ -56,11 +58,15 @@ module Minitest
     def prerecord(klass, name); end
 
     # Records the data from a result.
+    #
     # Minitest::Result source:
     #   https://github.com/seattlerb/minitest/blob/f4f57afaeb3a11bd0b86ab0757704cb78db96cf4/lib/minitest.rb#L504
     def record(result)
+      # Convert a Minitest Result into an "issue" to more consistently expose the data needed to
+      # adjust the failure output to the type of failure
       issue = Heat::Issue.new(result)
 
+      timer.increment_counts(issue.result.assertions)
       results.record(issue)
       map.add(*issue.to_hit) if issue.hit?
 
@@ -69,7 +75,7 @@ module Minitest
 
     # Outputs the summary of the run.
     def report
-      results.stop_timer!
+      timer.stop!
 
       # A couple of blank lines to create some breathing room
       output.newline
@@ -80,12 +86,14 @@ module Minitest
       #   This way, as you fix issues, the list gets shorter, and eventually the least critical
       #   issues will be displayed without scrolling once more problematic issues are resolved.
       %i[slows painfuls skips failures brokens errors].each do |issue_category|
+        next unless show?(issue_category)
+
         results.send(issue_category).each { |issue| output.issue_details(issue) }
       end
 
       # Display a short summary of the total issue counts fore ach category as well as performance
       # details for the test suite as a whole
-      output.compact_summary(results)
+      output.compact_summary(results, timer)
 
       # If there were issues, shows a short heat map summary of which files and lines were the most
       # common sources of issues
@@ -99,5 +107,23 @@ module Minitest
     def passed?
       results.errors.empty? && results.failures.empty?
     end
+
+    private
+
+    def no_problems?
+      !results.problems?
+    end
+
+    def no_problems_or_skips?
+      !results.problems? && !results.skips.any?
+    end
+
+    def show?(issue_category)
+      case issue_category
+      when :skips            then no_problems?
+      when :painfuls, :slows then no_problems_or_skips?
+      else true
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-heat
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Garrett Dimon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-08 00:00:00.000000000 Z
+date: 2021-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -158,6 +158,7 @@ files:
 - lib/minitest/heat/output/token.rb
 - lib/minitest/heat/results.rb
 - lib/minitest/heat/source.rb
+- lib/minitest/heat/timer.rb
 - lib/minitest/heat/version.rb
 - lib/minitest/heat_plugin.rb
 - lib/minitest/heat_reporter.rb