minitest-heat 0.0.5 → 0.0.9

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, :slows, :skips, :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_count_token, test_count_token]
-          @tokens << [assertions_performance_token, tests_performance_token, timing_token]
+
+          @tokens << [
+            timing_token, spacer_token,
+            test_count_token, tests_performance_token, join_token,
+            assertions_count_token, assertions_performance_token
+          ]
 
           @tokens
         end
@@ -33,16 +39,23 @@ module Minitest
         end
 
         def issue_counts_tokens
-          return unless problems? || slows?
+          return unless issues.any?
 
-          counts = [error_count_token, broken_count_token, failure_count_token, skip_count_token, slow_count_token].compact
+          counts = [
+            error_count_token,
+            broken_count_token,
+            failure_count_token,
+            skip_count_token,
+            painful_count_token,
+            slow_count_token
+          ].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
-                                    .flatten(1) # Flatten the zipped separators, but no more
+                                   .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
 
@@ -66,29 +79,34 @@ module Minitest
           issue_count_token(style, skips, name: 'Skip')
         end
 
+        def painful_count_token
+          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)
@@ -97,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/source_code.rb

@@ -101,9 +101,9 @@ module Minitest
         # @return [Array<Symbol>] the Token styles for the line number and line of code
         def styles_for(line_of_code)
           if line_of_code == source.line && highlight_key_line?
-            [:default, :default]
+            %i[default default]
           else
-            [:muted, :muted]
+            %i[muted muted]
           end
         end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Minitest
   module Heat
     # Friendly API for printing nicely-formatted output to the console
@@ -6,18 +8,18 @@ module Minitest
         class InvalidStyle < ArgumentError; end
 
         STYLES = {
-          success:       %i[default green],
-          slow:          %i[bold green],
-          painful:       %i[bold green],
-          error:         %i[bold red],
-          broken:        %i[bold red],
-          failure:       %i[default red],
-          skipped:       %i[default yellow],
+          success: %i[default green],
+          slow: %i[default green],
+          painful: %i[bold green],
+          error: %i[bold red],
+          broken: %i[bold red],
+          failure: %i[default red],
+          skipped: %i[default yellow],
           warning_light: %i[light yellow],
-          italicized:    %i[italic gray],
-          bold:          %i[bold default],
-          default:       %i[default default],
-          muted:         %i[light gray]
+          italicized: %i[italic gray],
+          bold: %i[bold default],
+          default: %i[default default],
+          muted: %i[light gray]
         }.freeze
 
         attr_accessor :style_key, :content
@@ -38,14 +40,14 @@ module Minitest
         end
 
         def eql?(other)
-          style_key == other.style_key &&  content == other.content
+          style_key == other.style_key && content == other.content
         end
         alias :== eql?
 
         private
 
         ESC_SEQUENCE = "\e["
-        END_SEQUENCE = "m"
+        END_SEQUENCE = 'm'
 
         WEIGHTS = {
           default: 0,

data/lib/minitest/heat/output.rb

@@ -2,8 +2,8 @@
 
 require_relative 'output/backtrace'
 require_relative 'output/issue'
-require_relative 'output/location'
 require_relative 'output/map'
+require_relative 'output/marker'
 require_relative 'output/results'
 require_relative 'output/source_code'
 require_relative 'output/token'
@@ -12,33 +12,16 @@ module Minitest
   module Heat
     # Friendly API for printing nicely-formatted output to the console
     class Output
-      FORMATTERS = {
-        error: [
-          [ %i[error label], %i[muted spacer], %i[default test_name] ],
-          [ %i[italicized summary], ],
-          [ %i[default backtrace_summary] ],
-        ],
-        broken: [
-          [ %i[broken label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[muted test_class] ],
-          [ %i[italicized summary], ],
-          [ %i[default backtrace_summary] ],
-        ],
-        failure: [
-          [ %i[failure label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[muted test_class] ],
-          [ %i[italicized summary] ],
-          [ %i[muted short_location], ],
-          [ %i[default source_summary], ],
-        ],
-        skipped: [
-          [ %i[skipped label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[muted test_class] ],
-          [ %i[italicized summary] ],
-          [], # New Line
-        ],
-        slow: [
-          [ %i[slow label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[default test_class] ],
-          [ %i[bold slowness], %i[muted spacer], %i[default location], ],
-          [], # New Line
-        ]
+      SYMBOLS = {
+        middot: '·',
+        arrow: '➜',
+        lead: '|',
+      }.freeze
+
+      TOKENS = {
+        spacer:      [:muted, " #{SYMBOLS[:middot]} "],
+        muted_arrow: [:muted, " #{SYMBOLS[:arrow]} "],
+        muted_lead:  [:muted, "#{SYMBOLS[:lead]} "],
       }
 
       attr_reader :stream
@@ -59,106 +42,22 @@ module Minitest
       end
       alias newline puts
 
-      # TOOD: Convert to output class
-      #       - This should likely live in the output/issue class
-      #       - Add a 'fail_fast' option that shows the issue as soon as the failure occurs
-      def marker(value)
-        case value
-        when 'E' then text(:error, value)
-        when 'B' then text(:failure, value)
-        when 'F' then text(:failure, value)
-        when 'S' then text(:skipped, value)
-        else          text(:success, value)
-        end
-      end
-
-      # TOOD: Convert to output class
-      #       - This should likely live in the output/issue class
-      #       - There may be justification for creating different "strategies" for the various types
       def issue_details(issue)
-        formatter = FORMATTERS[issue.type]
-
-        formatter.each do |lines|
-          lines.each do |tokens|
-            style, content_method = *tokens
-
-            if issue.respond_to?(content_method)
-              # If it's an available method on issue, use that to get the content
-              content = issue.send(content_method)
-              text(style, content)
-            else
-              # Otherwise, fall back to output and pass issue to *it*
-              send(content_method, issue)
-            end
-          end
-          newline
-        end
+        print_tokens Minitest::Heat::Output::Issue.new(issue).tokens
       end
 
-      # TOOD: Convert to output class
-      def heat_map(map)
-        map.files.each do |file|
-          pathname = Pathname(file[0])
-
-          path = pathname.dirname.to_s
-          filename = pathname.basename.to_s
-
-          values = map.hits[pathname.to_s]
-
-
-          text(:error, 'E' * values[:error].size)     if values[:error]&.any?
-          text(:broken, 'B' * values[:broken].size)   if values[:broken]&.any?
-          text(:failure, 'F' * values[:failure].size) if values[:failure]&.any?
-
-          unless values[:error]&.any? || values[:broken]&.any? || values[:failure]&.any?
-            text(:skipped, 'S' * values[:skipped].size) if values[:skipped]&.any?
-            text(:painful, '—' * values[:painful].size) if values[:painful]&.any?
-            text(:slow, '–' * values[:slow].size)       if values[:slow]&.any?
-          end
-
-          text(:muted, ' ') if map.hits.any?
-
-          text(:muted, "#{path.delete_prefix(Dir.pwd)}/")
-          text(:default, filename)
-
-          text(:muted, ':')
-
-          all_line_numbers = values.fetch(:error, []) + values.fetch(:failure, [])
-          all_line_numbers += values.fetch(:skipped, [])
-
-          line_numbers = all_line_numbers.compact.uniq.sort
-          line_numbers.each { |line_number| text(:muted, "#{line_number} ") }
-          newline
-        end
-        newline
+      def marker(issue_type)
+        print_token Minitest::Heat::Output::Marker.new(issue_type).token
       end
 
-      # TOOD: Convert to output class
-      def test_name_summary(issue)
-        text(:default, "#{issue.test_class} > #{issue.test_name}")
-      end
-
-      def compact_summary(results)
-        results_tokens = ::Minitest::Heat::Output::Results.new(results).tokens
-
-        newline
-        print_tokens(results_tokens)
+      def compact_summary(results, timer)
         newline
+        print_tokens ::Minitest::Heat::Output::Results.new(results, timer).tokens
       end
 
-      def backtrace_summary(issue)
-        location = issue.location
-
-        backtrace_tokens = ::Minitest::Heat::Output::Backtrace.new(location).tokens
-        print_tokens(backtrace_tokens)
-      end
-
-      def source_summary(issue)
-        filename    = issue.location.project_file
-        line_number = issue.location.project_failure_line
-
-        source_code_tokens = ::Minitest::Heat::Output::SourceCode.new(filename, line_number).tokens
-        print_tokens(source_code_tokens)
+      def heat_map(map)
+        newline
+        print_tokens ::Minitest::Heat::Output::Map.new(map).tokens
       end
 
       private
@@ -176,6 +75,10 @@ module Minitest
         style_enabled? ? :styled : :unstyled
       end
 
+      def print_token(token)
+        print Token.new(*token).to_s(token_format)
+      end
+
       def print_tokens(lines_of_tokens)
         lines_of_tokens.each do |tokens|
           tokens.each do |token|

data/lib/minitest/heat/results.rb

@@ -2,108 +2,52 @@
 
 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, :heat_map
 
       def initialize
-        @test_count = 0
-        @assertion_count = 0
-        @success_count = 0
-        @issues = {
-          error: [],
-          broken: [],
-          failure: [],
-          skipped: [],
-          slow: []
-        }
-        @start_time = nil
-        @stop_time = nil
-      end
-
-      def start_timer!
-        @start_time = Minitest.clock_time
+        @issues = []
+        @heat_map = Heat::Map.new
       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.push(issue)
+        @heat_map.add(*issue.to_hit) if issue.hit?
       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 slows
-        issues
-          .fetch(:slow) { [] }
-          .sort { |issue| issue.time }
-          .reverse
-          .take(3)
-      end
-
-      def errors?
-        errors.any?
+      def painfuls
+        @painfuls ||= select_issues(:painful).sort_by(&:time).reverse
       end
 
-      def brokens?
-        brokens.any?
-      end
-
-      def failures?
-        failures.any?
-      end
-
-      def skips?
-        skips.any?
-      end
-
-      def slows?
-        slows.any?
+      def slows
+        @slows ||= select_issues(:slow).sort_by(&:time).reverse
       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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Minitest
   module Heat
-    VERSION = "0.0.5"
+    VERSION = '0.0.9'
   end
 end

data/lib/minitest/heat.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require_relative 'heat/backtrace'
+require_relative 'heat/hit'
 require_relative 'heat/issue'
+require_relative 'heat/line'
 require_relative 'heat/location'
 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_plugin.rb

@@ -3,12 +3,12 @@
 require_relative 'heat_reporter'
 
 module Minitest
-  def self.plugin_heat_options(opts, options)
-    opts.on '--show-fast', "Show failures as they happen instead of waiting for the entire suite." do
+  def self.plugin_heat_options(opts, _options)
+    opts.on '--show-fast', 'Show failures as they happen instead of waiting for the entire suite.' do
       # Heat.show_fast!
     end
 
-    # TODO options.
+    # TODO: options.
     # 1. Fail Fast
     # 2. Don't worry about skips.
     # 3. Skip coverage.
@@ -18,9 +18,9 @@ module Minitest
     io = options[:io]
 
     # Clean out the existing reporters.
-    self.reporter.reporters = []
+    reporter.reporters = []
 
     # Use Reviewer as the sole reporter.
-    self.reporter << HeatReporter.new(io, options)
+    reporter << HeatReporter.new(io, options)
   end
 end