minitest-heat 0.0.6 → 0.0.10

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

@@ -2,8 +2,8 @@
 
 module Minitest
   module Heat
-    # Friendly API for printing nicely-formatted output to the console
     class Output
+      # Friendly API for printing consistent markers for the various issue types
       class Marker
         SYMBOLS = {
           success: '·',
@@ -12,7 +12,8 @@ module Minitest
           broken: 'B',
           error: 'E',
           skipped: 'S',
-          failure: 'F'
+          failure: 'F',
+          reporter: '✖'
         }.freeze
 
         STYLES = {
@@ -22,7 +23,8 @@ module Minitest
           broken: :error,
           error: :error,
           skipped: :skipped,
-          failure: :failure
+          failure: :failure,
+          reporter: :error
         }.freeze
 
         attr_accessor :issue_type

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

@@ -3,22 +3,29 @@
 module Minitest
   module Heat
     class Output
+      # Generates the output tokens to display the results summary
       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 +40,7 @@ module Minitest
         end
 
         def issue_counts_tokens
-          return unless problems? || slows?
+          return unless issues.any?
 
           counts = [
             error_count_token,
@@ -45,10 +52,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 +81,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').to_s]
         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').to_s]
         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 +116,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

@@ -3,7 +3,7 @@
 module Minitest
   module Heat
     class Output
-      # Builds the collection of tokens representing a specific set of source code lines
+      # Generates the tokens representing a specific set of source code lines
       class SourceCode
         DEFAULT_LINE_COUNT = 3
         DEFAULT_INDENTATION_SPACES = 2

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

@@ -2,8 +2,9 @@
 
 module Minitest
   module Heat
-    # Friendly API for printing nicely-formatted output to the console
     class Output
+      # Provides a convenient interface for creating console-friendly output while ensuring
+      #   consistency in the applied styles.
       class Token
         class InvalidStyle < ArgumentError; 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]} "]
+      }.freeze
+
       attr_reader :stream
 
       def initialize(stream = $stdout)
@@ -30,26 +42,82 @@ module Minitest
       end
       alias newline puts
 
+      def issues_list(results)
+        # A couple of blank lines to create some breathing room
+        newline
+        newline
+
+        # Issues start with the least critical and go up to the most critical so that the most
+        #   pressing issues are displayed at the bottom of the report in order to reduce scrolling.
+        #   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)
+
+          results.send(issue_category).each { |issue| issue_details(issue) }
+        end
+      rescue => e
+        message = "Sorry, but Minitest Heat couldn't display the details of any failures."
+        exception_guidance(message, e)
+      end
+
       def issue_details(issue)
         print_tokens Minitest::Heat::Output::Issue.new(issue).tokens
+      rescue => e
+        message = "Sorry, but Minitest Heat couldn't display output for a failure."
+        exception_guidance(message, e)
       end
 
       def marker(issue_type)
         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
+      rescue => e
+        message = "Sorry, but Minitest Heat couldn't display the summary."
+        exception_guidance(message, e)
       end
 
       def heat_map(map)
         newline
         print_tokens ::Minitest::Heat::Output::Map.new(map).tokens
+        newline
+      rescue => e
+        message = "Sorry, but Minitest Heat couldn't display the heat map."
+        exception_guidance(message, e)
+      end
+
+      def exception_guidance(message, exception)
+        newline
+        puts "#{message} Disabling Minitest Heat can get you back on track until the problem can be fixed."
+        puts "Please use the following exception details to submit an issue at https://github.com/garrettdimon/minitest-heat/issues"
+        puts "#{exception.message}:"
+        exception.backtrace.each do |line|
+          puts "  #{line}"
+        end
+        newline
       end
 
       private
 
+      def no_problems?(results)
+        !results.problems?
+      end
+
+      def no_problems_or_skips?(results)
+        !results.problems? && results.skips.none?
+      end
+
+      def show?(issue_category, results)
+        case issue_category
+        when :skips            then no_problems?(results)
+        when :painfuls, :slows then no_problems_or_skips?(results)
+        else true
+        end
+      end
+
       def style_enabled?
         stream.tty?
       end

data/lib/minitest/heat/results.rb

@@ -4,119 +4,65 @@ 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: [],
-          painful: [],
-          slow: []
-        }
-        @start_time = nil
-        @stop_time = nil
+        @issues = []
+        @heat_map = Heat::Map.new
       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
+      # Logs an issue to the results for later reporting
+      # @param issue [Issue] the issue generated from a given test result
+      #
+      # @return [type] [description]
+      def record(issue)
+        # Record everything—even if it's a success
+        @issues.push(issue)
 
-        # Don't return 0
-        delta.zero? ? 0.1 : delta
+        # If it's not a genuine problem, we're done here, otherwise update the heat map
+        update_heat_map(issue) if issue.hit?
       end
 
-      def tests_per_second
-        (assertion_count / total_time).round(2)
-      end
+      def update_heat_map(issue)
+        # Get the elements we need to generate a heat map entry
+        pathname    = issue.location.project_file.to_s
+        line_number = issue.location.project_failure_line.to_i
 
-      def assertions_per_second
-        (assertion_count / total_time).round(2)
+        @heat_map.add(pathname, line_number, issue.type)
       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(&:execution_time).reverse
       end
 
       def slows
-        issues
-          .fetch(:slow) { [] }
-          .sort_by(&:time)
-          .reverse
-          .take(5)
-      end
-
-      def errors?
-        errors.any?
-      end
-
-      def brokens?
-        brokens.any?
+        @slows ||= select_issues(:slow).sort_by(&:execution_time).reverse
       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.10'
   end
 end

data/lib/minitest/heat.rb

@@ -3,16 +3,17 @@
 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
-  # Custom minitest reporter just for Reviewer. Focuses on printing directly actionable guidance.
+  # Custom Minitest reporter focused on generating output designed around efficiently identifying
+  # issues and potential solutions
   # - Colorize the Output
   # - What files had the most errors?
   # - Show the most impacted areas first.

data/lib/minitest/heat_plugin.rb

@@ -2,25 +2,17 @@
 
 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
-      # Heat.show_fast!
-    end
-
-    # TODO: options.
-    # 1. Fail Fast
-    # 2. Don't worry about skips.
-    # 3. Skip coverage.
-  end
-
+module Minitest # rubocop:disable Style/Documentation
   def self.plugin_heat_init(options)
-    io = options[:io]
+    io = options.fetch(:io, $stdout)
 
-    # Clean out the existing reporters.
-    reporter.reporters = []
+    self.reporter.reporters.reject! do |reporter|
+      # Minitest Heat acts as a unified Progress *and* Summary reporter. Using other reporters of
+      # those types in conjunction with it creates some overly-verbose output
+      reporter.is_a?(ProgressReporter) || reporter.is_a?(SummaryReporter)
+    end
 
-    # Use Reviewer as the sole reporter.
-    reporter << HeatReporter.new(io, options)
+    # Hook up Reviewer
+    self.reporter.reporters << HeatReporter.new(io, options)
   end
 end

data/lib/minitest/heat_reporter.rb

@@ -31,20 +31,22 @@ module Minitest
   class HeatReporter < AbstractReporter
     attr_reader :output,
                 :options,
-                :results,
-                :map
+                :timer,
+                :results
 
     def initialize(io = $stdout, options = {})
+      super()
+
       @options = options
 
+      @timer =    Heat::Timer.new
       @results =  Heat::Results.new
-      @map =      Heat::Map.new
       @output =   Heat::Output.new(io)
     end
 
     # 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,43 +58,47 @@ 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)
-      issue = Heat::Issue.new(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.from_result(result)
+
+      # Note the number of assertions for the performance summary
+      timer.increment_counts(issue.assertions)
 
+      # Record the issue to show details later
       results.record(issue)
-      map.add(*issue.to_hit) if issue.hit?
 
+      # Show the marker
       output.marker(issue.type)
+    rescue => e
+      output.newline
+      puts "Sorry, but Minitest Heat encountered an exception recording an issue. Disabling Minitest Heat will get you back on track."
+      puts "Please use the following exception details to submit an issue at https://github.com/garrettdimon/minitest-heat/issues"
+      puts "#{e.message}:"
+      e.backtrace.each do |line|
+        puts "  #{line}"
+      end
+      output.newline
     end
 
     # Outputs the summary of the run.
     def report
-      results.stop_timer!
-
-      # A couple of blank lines to create some breathing room
-      output.newline
-      output.newline
+      timer.stop!
 
-      # Issues start with the least critical and go up to the most critical so that the most
-      #   pressing issues are displayed at the bottom of the report in order to reduce scrolling.
-      #   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|
-        results.send(issue_category).each { |issue| output.issue_details(issue) }
-      end
+      # The list of individual issues and their associated details
+      output.issues_list(results)
 
       # 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
-      output.heat_map(map)
-
-      # A blank line to create some breathing room
-      output.newline
+      output.heat_map(results)
     end
 
     # Did this run pass?