minitest-heat 0.0.10 → 0.0.14

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

@@ -5,36 +5,25 @@ module Minitest
     class Output
       # Formats issues to output based on the issue type
       class Issue # rubocop:disable Metrics/ClassLength
-        attr_accessor :issue
+        attr_accessor :issue, :locations
 
         def initialize(issue)
           @issue = issue
+          @locations = issue.locations
         end
 
         def tokens
           case issue.type
-          when :error then error_tokens
-          when :broken then broken_tokens
-          when :failure then failure_tokens
-          when :skipped then skipped_tokens
-          when :painful then painful_tokens
-          when :slow then slow_tokens
+          when :error, :broken  then exception_tokens
+          when :failure         then failure_tokens
+          when :skipped         then skipped_tokens
+          when :painful, :slow  then slow_tokens
           end
         end
 
         private
 
-        def error_tokens
-          [
-            headline_tokens,
-            test_location_tokens,
-            summary_tokens,
-            *backtrace_tokens,
-            newline_tokens
-          ]
-        end
-
-        def broken_tokens
+        def exception_tokens
           [
             headline_tokens,
             test_location_tokens,
@@ -61,14 +50,6 @@ module Minitest
           ]
         end
 
-        def painful_tokens
-          [
-            headline_tokens,
-            slowness_summary_tokens,
-            newline_tokens
-          ]
-        end
-
         def slow_tokens
           [
             headline_tokens,
@@ -78,9 +59,14 @@ module Minitest
         end
 
         def headline_tokens
-          [[issue.type, label(issue)], spacer_token, [:default, test_name(issue)]]
+          [label_token(issue), spacer_token, [:default, test_name(issue)]]
         end
 
+        # Creates a display-friendly version of the test name with underscores removed and the
+        #   first letter capitalized regardless of the formatt used for the test definition
+        # @param issue [Issue] the issue to use to generate the test name
+        #
+        # @return [String] the cleaned up version of the test name
         def test_name(issue)
           test_prefix = 'test_'
           identifier = issue.test_identifier
@@ -92,50 +78,39 @@ module Minitest
           end
         end
 
-        def label(issue)
-          if issue.error? && issue.in_test?
-            # When the exception came out of the test itself, that's a different kind of exception
-            # that really only indicates there's a problem with the code in the test. It's kind of
-            # between an error and a test.
-            'Broken Test'
-          elsif issue.error?
-            'Error'
-          elsif issue.skipped?
-            'Skipped'
-          elsif issue.painful?
-            'Passed but Very Slow'
-          elsif issue.slow?
-            'Passed but Slow'
-          elsif !issue.passed?
-            'Failure'
-          else
-            'Success'
-          end
+        def label_token(issue)
+          [issue.type, issue_label(issue.type)]
         end
 
         def test_name_and_class_tokens
           [[:default, issue.test_class], *test_location_tokens]
         end
 
-        def backtrace_tokens
-          backtrace = ::Minitest::Heat::Output::Backtrace.new(issue.location)
-
-          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]]
+          [
+            [:default, locations.test_definition.relative_filename],
+            [:muted, ':'],
+            [:default, locations.test_definition.line_number],
+            arrow_token,
+            [:default, locations.test_failure.line_number],
+            [:muted, "\n  #{locations.test_failure.source_code.line.strip}"]
+          ]
         end
 
         def location_tokens
-          [[:default, most_relevant_short_location], [:muted, ':'], [:default, issue.location.most_relevant_failure_line], [:muted, most_relevant_line_source]]
+          [
+            [:default, locations.most_relevant.relative_filename],
+            [:muted, ':'],
+            [:default, locations.most_relevant.line_number],
+            [:muted, "\n  #{locations.most_relevant.source_code.line.strip}"]
+          ]
         end
 
         def source_tokens
-          filename    = issue.location.project_file
-          line_number = issue.location.project_failure_line
-
+          filename    = locations.project.filename
+          line_number = locations.project.line_number
           source = Minitest::Heat::Source.new(filename, line_number: line_number)
+
           [[:muted, " #{Output::SYMBOLS[:arrow]} `#{source.line.strip}`"]]
         end
 
@@ -147,9 +122,10 @@ module Minitest
           [
             [:bold, slowness(issue)],
             spacer_token,
-            [:default, issue.location.test_file.to_s.delete_prefix(Dir.pwd)],
+            [:default, locations.test_definition.relative_path],
+            [:default, locations.test_definition.filename],
             [:muted, ':'],
-            [:default, issue.location.test_definition_line]
+            [:default, locations.test_definition.line_number]
           ]
         end
 
@@ -161,30 +137,6 @@ module Minitest
           []
         end
 
-        def most_relevant_short_location
-          issue.location.most_relevant_file.to_s.delete_prefix("#{Dir.pwd}/")
-        end
-
-        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 spacer_token
           Output::TOKENS[:spacer]
         end
@@ -192,6 +144,27 @@ module Minitest
         def arrow_token
           Output::TOKENS[:muted_arrow]
         end
+
+        def backtrace_tokens
+          @backtrace_tokens ||= ::Minitest::Heat::Output::Backtrace.new(locations).tokens
+        end
+
+        # The string to use to describe the failure type when displaying results/
+        # @param issue_type [Symbol] the symbol representing the issue's failure type
+        #
+        # @return [String] the display-friendly string describing the failure reason
+        def issue_label(issue_type)
+          case issue_type
+          when :error   then 'Error'
+          when :broken  then 'Broken Test'
+          when :failure then 'Failure'
+          when :skipped then 'Skipped'
+          when :slow    then 'Passed but Slow'
+          when :painful then 'Passed but Very Slow'
+          when :passed  then 'Success'
+          else 'Unknown'
+          end
+        end
       end
     end
   end

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

@@ -13,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
@@ -30,8 +50,34 @@ 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
@@ -46,37 +92,79 @@ module Minitest
           issue_types
         end
 
-        def pathname(file)
-          directory = "#{file.pathname.dirname.to_s.delete_prefix(Dir.pwd)}/".delete_prefix('/')
-          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
 
-          [
-            [:default, directory],
-            [:bold, filename],
-            [:default, ' · ']
-          ]
+          intersection_issue_types.any?
         end
 
-        def hit_line_numbers(file, issue_type)
-          numbers = []
-          line_numbers_for_issue_type = file.issues.fetch(issue_type) { [] }
-          line_numbers_for_issue_type.map do |line_number|
-            numbers << [issue_type, "#{line_number} "]
+        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
 
-          numbers
+          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}/"],
+            [:bold, filename],
+            [:default, ' · ']
+          ]
         end
 
-        def line_numbers(file)
+        # 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 = []
 
-          # Merge the hits for all issue types into one list
           relevant_issue_types.each do |issue_type|
-            line_number_tokens += hit_line_numbers(file, 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
 
+          line_number_tokens.compact
+        end
+
+        # 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.compact.sort do |a, b|
+          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)

data/lib/minitest/heat/output.rb

@@ -11,7 +11,7 @@ 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: '➜',
@@ -48,23 +48,26 @@ module Minitest
         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.
+        # 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 => e
+      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 => e
-        message = "Sorry, but Minitest Heat couldn't display output for a failure."
+      rescue StandardError => e
+        message = "Sorry, but Minitest Heat couldn't display output for a specific failure."
         exception_guidance(message, e)
       end
 
@@ -75,7 +78,7 @@ module Minitest
       def compact_summary(results, timer)
         newline
         print_tokens ::Minitest::Heat::Output::Results.new(results, timer).tokens
-      rescue => e
+      rescue StandardError => e
         message = "Sorry, but Minitest Heat couldn't display the summary."
         exception_guidance(message, e)
       end
@@ -84,15 +87,24 @@ module Minitest
         newline
         print_tokens ::Minitest::Heat::Output::Map.new(map).tokens
         newline
-      rescue => e
+      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 '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}"
@@ -100,8 +112,6 @@ module Minitest
         newline
       end
 
-      private
-
       def no_problems?(results)
         !results.problems?
       end
@@ -138,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

@@ -19,16 +19,21 @@ module Minitest
         # Record everything—even if it's a success
         @issues.push(issue)
 
-        # If it's not a genuine problem, we're done here, otherwise update the heat map
-        update_heat_map(issue) 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)
-        # 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
+        # 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)
+        @heat_map.add(pathname, line_number, issue.type, backtrace: backtrace)
       end
 
       def problems?

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.10'
+    VERSION = '0.0.14'
   end
 end

data/lib/minitest/heat.rb

@@ -4,6 +4,7 @@ require_relative 'heat/backtrace'
 require_relative 'heat/hit'
 require_relative 'heat/issue'
 require_relative 'heat/location'
+require_relative 'heat/locations'
 require_relative 'heat/map'
 require_relative 'heat/output'
 require_relative 'heat/results'

data/lib/minitest/heat_plugin.rb

@@ -6,7 +6,7 @@ module Minitest # rubocop:disable Style/Documentation
   def self.plugin_heat_init(options)
     io = options.fetch(:io, $stdout)
 
-    self.reporter.reporters.reject! do |reporter|
+    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)

data/lib/minitest/heat_reporter.rb

@@ -74,12 +74,16 @@ module Minitest
 
       # Show the marker
       output.marker(issue.type)
-    rescue => e
+    rescue StandardError => e
+      display_exception_guidance(e)
+    end
+
+    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 "#{e.message}:"
-      e.backtrace.each do |line|
+      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
@@ -92,13 +96,16 @@ module Minitest
       # 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)
 
       # 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(results)
+
+      output.newline
+      output.newline
     end
 
     # Did this run pass?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-heat
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.14
 platform: ruby
 authors:
 - Garrett Dimon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-31 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.rb
+- lib/minitest/heat/backtrace/line_parser.rb
 - lib/minitest/heat/hit.rb
 - lib/minitest/heat/issue.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.