minitest-heat 0.0.9 → 0.0.13

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

@@ -3,6 +3,7 @@
 module Minitest
   module Heat
     class Output
+      # Generates the tokens to output the resulting heat map
       class Map
         attr_accessor :results
 
@@ -12,16 +13,36 @@ module Minitest
         end
 
         def tokens
-          map.file_hits.each do |hit|
-            file_tokens = pathname(hit)
-            line_number_tokens = line_numbers(hit)
+          results.heat_map.file_hits.each do |hit|
+            # Focus on the relevant issues based on most significant problems. i.e. If there are
+            # legitimate failures or errors, skips and slows aren't relevant
+            next unless relevant_issue_types?(hit)
 
-            next if line_number_tokens.empty?
+            # Add a new line
+            @tokens << [[:muted, ""]]
 
-            @tokens << [
-              *file_tokens,
-              *line_number_tokens
-            ]
+            # Build the summary line for the file
+            @tokens << file_summary_tokens(hit)
+
+            # Get the set of line numbers that appear more than once
+            repeated_line_numbers = find_repeated_line_numbers_in(hit)
+
+            # Only display more details if the same line number shows up more than once
+            next unless repeated_line_numbers.any?
+
+            repeated_line_numbers.each do |line_number|
+              # Get the backtraces for the given line numbers
+              traces = hit.lines[line_number.to_s]
+
+              # If there aren't any traces there's no way to provide additional details
+              break unless traces.any?
+
+              # A short summary explaining the details that will follow
+              @tokens << [[:muted, "  Issues on Line #{line_number} initially triggered from these locations:"]]
+
+              # The last relevant location for each error's backtrace
+              @tokens += origination_sources(traces)
+            end
           end
 
           @tokens
@@ -29,13 +50,41 @@ module Minitest
 
         private
 
-        def map
-          results.heat_map
+        def origination_sources(traces)
+          # 1. Sort the traces by the most recent line number so they're displayed in numeric order
+          # 2. Get the final relevant location from the trace
+          traces.
+            sort_by { |trace| trace.locations.last.line_number }.
+            map     { |trace| origination_location_token(trace) }
+        end
+
+        def file_summary_tokens(hit)
+          pathname_tokens = pathname(hit)
+          line_number_list_tokens = sorted_line_number_list(hit)
+
+          [*pathname_tokens, *line_number_list_tokens]
+        end
+
+        def origination_location_token(trace)
+          # The earliest project line from the backtrace—this is probabyl wholly incorrect in terms
+          # of what would be the most helpful line to display, but it's a start.
+          location = trace.locations.last
+
+          [
+            [:muted, "  #{Output::SYMBOLS[:arrow]} "],
+            [:default, location.relative_filename],
+            [:muted, ':'],
+            [:default, location.line_number],
+            [:muted, " in #{location.container}"],
+            [:muted, " #{Output::SYMBOLS[:arrow]} `#{location.source_code.line.strip}`"],
+          ]
         end
 
         def relevant_issue_types
+          # These are always relevant.
           issue_types = %i[error broken failure]
 
+          # These are only relevant if there aren't more serious isues.
           issue_types << :skipped unless results.problems?
           issue_types << :painful unless results.problems? || results.skips.any?
           issue_types << :slow    unless results.problems? || results.skips.any?
@@ -43,32 +92,85 @@ module Minitest
           issue_types
         end
 
-        def pathname(file)
-          directory = "#{file.pathname.dirname.to_s.delete_prefix(Dir.pwd)}/"
-          filename = file.pathname.basename.to_s
+        def relevant_issue_types?(hit)
+          # The intersection of which issue types are relevant based on the context and which issues
+          # matc those issue types
+          intersection_issue_types = relevant_issue_types & hit.issues.keys
+
+          intersection_issue_types.any?
+        end
+
+        def find_repeated_line_numbers_in(hit)
+          repeated_line_numbers = []
+
+          hit.lines.each_pair do |line_number, traces|
+            # If there aren't multiple traces for a line number, it's not a repeat
+            next unless traces.size > 1
+
+            repeated_line_numbers << Integer(line_number)
+          end
+
+          repeated_line_numbers.sort
+        end
+
+        def pathname(hit)
+          directory = hit.pathname.dirname.to_s.delete_prefix("#{Dir.pwd}/")
+          filename = hit.pathname.basename.to_s
 
           [
-            [:default, directory],
+            [:default, "#{directory}/"],
             [:bold, filename],
             [:default, ' · ']
           ]
         end
 
-        def hit_line_numbers(file, issue_type)
-          numbers = []
-          line_numbers_for_issue_type = file.issues.fetch(issue_type) { [] }
-          line_numbers_for_issue_type.sort.map do |line_number|
-            numbers << [issue_type, "#{line_number} "]
+        # Gets the list of line numbers for a given hit location (i.e. file) so they can be
+        #   displayed after the file name to show which lines were problematic
+        # @param hit [Hit] the instance to extract line numbers from
+        #
+        # @return [Array<Symbol,String>] [description]
+        def line_number_tokens_for_hit(hit)
+          line_number_tokens = []
+
+          relevant_issue_types.each do |issue_type|
+            # Retrieve any line numbers for the issue type
+            line_numbers_for_issue_type = hit.issues.fetch(issue_type) { [] }
+
+            # Build the list of tokens representing styled line numbers
+            line_numbers_for_issue_type.each do |line_number|
+              line_number_tokens << line_number_token(issue_type, line_number)
+            end
           end
-          numbers
+
+          line_number_tokens.compact
         end
 
-        def line_numbers(file)
-          line_number_tokens = []
-          relevant_issue_types.each do |issue_type|
-            line_number_tokens += hit_line_numbers(file, issue_type)
+        # Builds a token representing a styled line number
+        #
+        # @param style [Symbol] the relevant display style for the issue
+        # @param line_number [Integer] the affected line number
+        #
+        # @return [Array<Symbol,Integer>] array token representing the line number and issue type
+        def line_number_token(style, line_number)
+          [style, "#{line_number} "]
+        end
+
+        # Sorts line number tokens so that line numbers are displayed in order regardless of their
+        #   underlying issue type
+        #
+        # @param hit [Hit] the instance of the hit file details to build the heat map entry
+        #
+        # @return [Array] the arrays representing the line number tokens to display next to a file
+        #   name in the heat map. ex [[:error, 12], [:falure, 13]]
+        def sorted_line_number_list(hit)
+          # Sort the collected group of line number hits so they're in order
+          line_number_tokens_for_hit(hit).sort do |a, b|
+            # Ensure the line numbers are integers for sorting (otherwise '100' comes before '12')
+            first_line_number = Integer(a[1].strip)
+            second_line_number = Integer(b[1].strip)
+
+            first_line_number <=> second_line_number
           end
-          line_number_tokens.compact.sort_by { |number_token| number_token[1] }
         end
       end
     end

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,6 +3,7 @@
 module Minitest
   module Heat
     class Output
+      # Generates the output tokens to display the results summary
       class Results
         extend Forwardable
 
@@ -90,7 +91,7 @@ module Minitest
         end
 
         def test_count_token
-          [:default, "#{pluralize(timer.test_count, 'test')}"]
+          [:default, pluralize(timer.test_count, 'test').to_s]
         end
 
         def tests_performance_token
@@ -98,7 +99,7 @@ module Minitest
         end
 
         def assertions_count_token
-          [:default, "#{pluralize(timer.assertion_count, 'assertion')}"]
+          [:default, pluralize(timer.assertion_count, 'assertion').to_s]
         end
 
         def assertions_performance_token

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

@@ -11,18 +11,18 @@ require_relative 'output/token'
 module Minitest
   module Heat
     # Friendly API for printing nicely-formatted output to the console
-    class Output
+    class Output # rubocop:disable Metrics/ClassLength
       SYMBOLS = {
         middot: '·',
         arrow: '➜',
-        lead: '|',
+        lead: '|'
       }.freeze
 
       TOKENS = {
-        spacer:      [:muted, " #{SYMBOLS[:middot]} "],
+        spacer: [:muted, " #{SYMBOLS[:middot]} "],
         muted_arrow: [:muted, " #{SYMBOLS[:arrow]} "],
-        muted_lead:  [:muted, "#{SYMBOLS[:lead]} "],
-      }
+        muted_lead: [:muted, "#{SYMBOLS[:lead]} "]
+      }.freeze
 
       attr_reader :stream
 
@@ -42,8 +42,33 @@ 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|
+          # Only show categories for the most pressing issues after the suite runs, otherwise,
+          # suppress them until the more critical issues are resolved.
+          next unless show?(issue_category, results)
+
+          results.send(issue_category).each { |issue| issue_details(issue) }
+        end
+      rescue StandardError => 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 StandardError => e
+        message = "Sorry, but Minitest Heat couldn't display output for a specific failure."
+        exception_guidance(message, e)
       end
 
       def marker(issue_type)
@@ -53,15 +78,56 @@ module Minitest
       def compact_summary(results, timer)
         newline
         print_tokens ::Minitest::Heat::Output::Results.new(results, timer).tokens
+      rescue StandardError => 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 StandardError => e
+        message = "Sorry, but Minitest Heat couldn't display the heat map."
+        exception_guidance(message, e)
       end
 
       private
 
+      # Displays some guidance related to exceptions generated by Minitest Heat in order to help
+      #   people get back on track (and ideally submit issues)
+      # @param message [String] a slightly more specific explanation of which part of minitest-heat
+      #   caused the failure
+      # @param exception [Exception] the exception that caused the problem
+      #
+      # @return [void] displays the guidance to the console
+      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
+
+      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
@@ -82,7 +148,11 @@ module Minitest
       def print_tokens(lines_of_tokens)
         lines_of_tokens.each do |tokens|
           tokens.each do |token|
-            print Token.new(*token).to_s(token_format)
+            begin
+              print Token.new(*token).to_s(token_format)
+            rescue
+              puts token.inspect
+            end
           end
           newline
         end

data/lib/minitest/heat/results.rb

@@ -11,9 +11,29 @@ module Minitest
         @heat_map = Heat::Map.new
       end
 
+      # 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)
-        @heat_map.add(*issue.to_hit) if issue.hit?
+
+        # If it's not a genuine problem, we're done here...
+        return unless issue.hit?
+
+        # ...otherwise update the heat map
+        update_heat_map(issue)
+      end
+
+      def update_heat_map(issue)
+        # For heat map purposes, only the project backtrace lines are interesting
+        pathname, line_number = issue.locations.project.to_a
+
+        # Backtrace is only relevant for exception-generating issues, not slows, skips, or failures
+        backtrace = issue.error? ? issue.locations.backtrace.project_locations : []
+
+        @heat_map.add(pathname, line_number, issue.type, backtrace: backtrace)
       end
 
       def problems?
@@ -37,11 +57,11 @@ module Minitest
       end
 
       def painfuls
-        @painfuls ||= select_issues(:painful).sort_by(&:time).reverse
+        @painfuls ||= select_issues(:painful).sort_by(&:execution_time).reverse
       end
 
       def slows
-        @slows ||= select_issues(:slow).sort_by(&:time).reverse
+        @slows ||= select_issues(:slow).sort_by(&:execution_time).reverse
       end
 
       private

data/lib/minitest/heat/source.rb

@@ -35,7 +35,7 @@ module Minitest
       #
       # @return [Array<String>] the range of lines of code around
       def lines
-        return [line] if max_line_count == 1
+        return [line].compact if max_line_count == 1
 
         file_lines[(line_numbers.first - 1)..(line_numbers.last - 1)]
       end

data/lib/minitest/heat/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Heat
-    VERSION = '0.0.9'
+    VERSION = '0.0.13'
   end
 end

data/lib/minitest/heat.rb

@@ -3,8 +3,8 @@
 require_relative 'heat/backtrace'
 require_relative 'heat/hit'
 require_relative 'heat/issue'
-require_relative 'heat/line'
 require_relative 'heat/location'
+require_relative 'heat/locations'
 require_relative 'heat/map'
 require_relative 'heat/output'
 require_relative 'heat/results'
@@ -13,7 +13,8 @@ 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 = []
+    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

@@ -35,6 +35,8 @@ module Minitest
                 :results
 
     def initialize(io = $stdout, options = {})
+      super()
+
       @options = options
 
       @timer =    Heat::Timer.new
@@ -62,33 +64,39 @@ module Minitest
     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)
+      issue = Heat::Issue.from_result(result)
+
+      # Note the number of assertions for the performance summary
+      timer.increment_counts(issue.assertions)
 
-      timer.increment_counts(issue.result.assertions)
+      # Record the issue to show details later
       results.record(issue)
 
+      # Show the marker
       output.marker(issue.type)
+    rescue StandardError => e
+      display_exception_guidance(e)
     end
 
-    # Outputs the summary of the run.
-    def report
-      timer.stop!
-
-      # A couple of blank lines to create some breathing room
+    def display_exception_guidance(exception)
       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 "#{exception.message}:"
+      exception.backtrace.each do |line|
+        puts "  #{line}"
+      end
       output.newline
+    end
 
-      # 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)
+    # Outputs the summary of the run.
+    def report
+      timer.stop!
 
-        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
+      # Display a short summary of the total issue counts for each category as well as performance
       # details for the test suite as a whole
       output.compact_summary(results, timer)
 
@@ -96,7 +104,7 @@ module Minitest
       # common sources of issues
       output.heat_map(results)
 
-      # A blank line to create some breathing room
+      output.newline
       output.newline
     end
 
@@ -104,23 +112,5 @@ 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.9
+  version: 0.0.13
 platform: ruby
 authors:
 - Garrett Dimon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-26 00:00:00.000000000 Z
+date: 2021-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -141,12 +141,19 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/exceptions.png
+- examples/failures.png
+- examples/map.png
+- examples/markers.png
+- examples/skips.png
+- examples/slows.png
 - lib/minitest/heat.rb
 - lib/minitest/heat/backtrace.rb
+- lib/minitest/heat/backtrace/line_parser.rb
 - lib/minitest/heat/hit.rb
 - lib/minitest/heat/issue.rb
-- lib/minitest/heat/line.rb
 - lib/minitest/heat/location.rb
+- lib/minitest/heat/locations.rb
 - lib/minitest/heat/map.rb
 - lib/minitest/heat/output.rb
 - lib/minitest/heat/output/backtrace.rb
@@ -188,7 +195,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Presents test results in a visual manner to guide you to where to look first.