minitest-heat 0.0.10 → 0.0.11

data/lib/minitest/heat/locations.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    # Convenience methods for determining the file and line number where the problem occurred.
+    #   There are several layers of specificity to help make it easy to communicate the relative
+    #   location of the failure:
+    #   - 'final' represents the final line of the backtrace regardless of where it is
+    #   - 'test_definition' represents where the test is defined
+    #   - 'test_failure' represents the last line from the project's tests. It is further differentiated by
+    #     the line where the test is defined and the actual line of code in the test that geneated
+    #     the failure or exception
+    #   - 'source_code' represents the last line from the project's source code
+    #   - 'project' represents the last source line, but falls back to the last test line
+    #   - 'most_relevant' represents the most specific file to investigate starting with the source
+    #     code and then looking to the test code with final line of the backtrace as a fallback
+    class Locations
+      attr_reader :test_definition, :backtrace
+
+      def initialize(test_definition_location, backtrace = [])
+        test_definition_pathname, test_definition_line_number = test_definition_location
+        @test_definition          = ::Minitest::Heat::Location.new(pathname: test_definition_pathname, line_number: test_definition_line_number)
+
+        @backtrace = Backtrace.new(backtrace)
+      end
+
+      # Prints the pathname and line number of the location most likely to be the source of the
+      #   test failure
+      #
+      # @return [String] ex. 'path/to/file.rb:12'
+      def to_s
+        "#{most_relevant.absolute_filename}:#{most_relevant.line_number}"
+      end
+
+      # Knows if the failure is contained within the test. For example, if there's bad code in a
+      #   test, and it raises an exception, then it's really a broken test rather than a proper
+      #   faiure.
+      #
+      # @return [Boolean] true if final file in the backtrace is the same as the test location file
+      def broken_test?
+        !test_failure.nil? && test_failure == final
+      end
+
+      # Knows if the failure occurred in the actual project source code—as opposed to the test or
+      #   an external piece of code like a gem.
+      #
+      # @return [Boolean] true if there's a non-test project file in the stacktrace but it's not
+      #   a result of a broken test
+      def proper_failure?
+        !source_code.nil? && !broken_test?
+      end
+
+      # The file most likely to be the source of the underlying problem. Often, the most recent
+      #   backtrace files will be a gem or external library that's failing indirectly as a result
+      #   of a problem with local source code (not always, but frequently). In that case, the best
+      #   first place to focus is on the code you control.
+      #
+      # @return [Array] file and line number of the most likely source of the problem
+      def most_relevant
+        [
+          source_code,
+          test_failure,
+          final
+        ].compact.first
+      end
+
+      def freshest
+        backtrace.recently_modified_locations.first
+      end
+
+      # Returns the final test location based on the backtrace if present. Otherwise falls back to
+      #   the test location which represents the test definition. The `test_definition` attribute
+      #   provides the location of where the test is defined. `test_failure` represents the actual
+      #   line from within the test where the problem occurred
+      #
+      # @return [Location] the final location from the test files
+      def test_failure
+        backtrace.test_locations.any? ? backtrace.test_locations.first : test_definition
+      end
+
+      # Returns the final source code location based on the backtrace
+      #
+      # @return [Location] the final location from the source code files
+      def source_code
+        backtrace.source_code_locations.first
+      end
+
+      # Returns the final project location based on the backtrace if present. Otherwise falls back
+      #   to the test location which represents the test definition.
+      #
+      # @return [Location] the final location from the project files
+      def project
+        backtrace.project_locations.any? ? backtrace.project_locations.first : test_definition
+      end
+
+      # The line number from within the `test_file` test definition where the failure occurred
+      #
+      # @return [Location] the last location from the backtrace or the test location if a backtrace
+      #   was not passed to the initializer
+      def final
+        backtrace.locations.any? ? backtrace.locations.first : test_definition
+      end
+    end
+  end
+end

data/lib/minitest/heat/map.rb

@@ -18,10 +18,9 @@ module Minitest
       # @param type [Symbol] the type of issue that was encountered (i.e. :failure, :error, etc.)
       #
       # @return [void]
-      def add(filename, line_number, type)
-        @hits[filename] ||= Hit.new(filename)
-
-        @hits[filename].log(type.to_sym, line_number)
+      def add(pathname, line_number, type, backtrace: [])
+        @hits[pathname.to_s] ||= Hit.new(pathname)
+        @hits[pathname.to_s].log(type.to_sym, line_number, backtrace: backtrace)
       end
 
       # Returns a subset of affected files to keep the list from being overwhelming

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

@@ -8,11 +8,11 @@ module Minitest
         DEFAULT_LINE_COUNT = 10
         DEFAULT_INDENTATION_SPACES = 2
 
-        attr_accessor :location, :backtrace
+        attr_accessor :locations, :backtrace
 
-        def initialize(location)
-          @location = location
-          @backtrace = location.backtrace
+        def initialize(locations)
+          @locations = locations
+          @backtrace = locations.backtrace
           @tokens = []
         end
 
@@ -21,14 +21,8 @@ module Minitest
           # final backtrace line if it might be relevant/helpful?
 
           # Iterate over the selected lines from the backtrace
-          backtrace_entries.each do |backtrace_entry|
-            # Get the source code for the line from the backtrace
-            parts = backtrace_line_tokens(backtrace_entry)
-
-            # If it's the most recently modified file in the trace, add the token for that
-            parts << file_freshness(backtrace_entry) if most_recently_modified?(backtrace_entry)
-
-            @tokens << parts
+          backtrace_locations.each do |location|
+            @tokens << backtrace_location_tokens(location)
           end
 
           @tokens
@@ -47,71 +41,74 @@ module Minitest
         # ...it could be influenced by a "compact" or "robust" reporter super-style?
         # ...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
-          all_entries
+        def backtrace_locations
+          backtrace.locations.take(line_count)
         end
 
         private
 
-        def backtrace_line_tokens(backtrace_entry)
+        def backtrace_location_tokens(location)
           [
             indentation_token,
-            path_token(backtrace_entry),
-            *file_and_line_number_tokens(backtrace_entry),
-            source_code_line_token(backtrace_entry.source_code)
-          ]
-        end
-
-        def all_backtrace_entries_from_project?
-          backtrace_entries.all? { |line| line.path.to_s.include?(project_root_dir) }
-        end
-
-        def project_root_dir
-          Dir.pwd
-        end
-
-        def project_entries
-          backtrace.project_entries.take(line_count)
+            path_token(location),
+            *file_and_line_number_tokens(location),
+            containining_element_token(location),
+            source_code_line_token(location),
+            most_recently_modified_token(location),
+          ].compact
         end
 
-        def all_entries
-          backtrace.parsed_entries.take(line_count)
+        # Determines if all lines to be displayed are from within the project directory
+        #
+        # @return [Boolean] true if all lines of the backtrace being displayed are from the project
+        def all_backtrace_from_project?
+          backtrace_locations.all?(&:project_file?)
         end
 
-        def most_recently_modified?(line)
+        def most_recently_modified?(location)
           # If there's more than one line being displayed, and the current line is the freshest
-          backtrace_entries.size > 1 && line == backtrace.freshest_project_location
+          backtrace_locations.size > 1 && location == locations.freshest
         end
 
         def indentation_token
           [:default, ' ' * indentation]
         end
 
-        def path_token(line)
-          style = line.to_s.include?(Dir.pwd) ? :default : :muted
-          path = "#{line.path}/"
+        def path_token(location)
+          # If the line is a project file, help it stand out from the backtrace noise
+          style = location.project_file? ? :default : :muted
 
-          # If all of the backtrace lines are from the project, no point in the added redundant
-          #  noise of showing the project root directory over and over again
-          path = path.delete_prefix(project_root_dir) if all_backtrace_entries_from_project?
+          # If *all* of the backtrace lines are from the project, no point in the added redundant
+          # noise of showing the project root directory over and over again
+          path_format = all_backtrace_from_project? ? :relative_path : :absolute_path
 
-          [style, path]
+          [style, location.send(path_format)]
         end
 
-        def file_and_line_number_tokens(backtrace_entry)
-          style = backtrace_entry.to_s.include?(Dir.pwd) ? :bold : :muted
+        def file_and_line_number_tokens(location)
+          style = location.to_s.include?(Dir.pwd) ? :bold : :muted
           [
-            [style, backtrace_entry.file],
+            [style, location.filename],
             [:muted, ':'],
-            [style, backtrace_entry.line_number]
+            [style, location.line_number]
           ]
         end
 
-        def source_code_line_token(source_code)
-          [:muted, " #{Output::SYMBOLS[:arrow]} `#{source_code.line.strip}`"]
+        def source_code_line_token(location)
+          return nil unless location.project_file?
+
+          [:muted, " #{Output::SYMBOLS[:arrow]} `#{location.source_code.line.strip}`"]
+        end
+
+        def containining_element_token(location)
+          return nil if !location.project_file? || location.container.nil? || location.container.empty?
+
+          [:muted, " in #{location.container}"]
         end
 
-        def file_freshness(_line)
+        def most_recently_modified_token(location)
+          return nil unless most_recently_modified?(location)
+
           [:default, " #{Output::SYMBOLS[:middot]} Most Recently Modified File"]
         end
 
@@ -126,10 +123,6 @@ module Minitest
         def indentation
           DEFAULT_INDENTATION_SPACES
         end
-
-        def style_for(path)
-          path.to_s.include?(Dir.pwd) ? :default : :muted
-        end
       end
     end
   end

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

@@ -5,10 +5,11 @@ 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
@@ -92,7 +93,7 @@ module Minitest
           end
         end
 
-        def label(issue)
+        def label(issue) # rubocop:disable Metrics
           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
@@ -118,24 +119,34 @@ module Minitest
         end
 
         def backtrace_tokens
-          backtrace = ::Minitest::Heat::Output::Backtrace.new(issue.location)
-
-          backtrace.tokens
+          @backtrace_tokens ||= ::Minitest::Heat::Output::Backtrace.new(locations).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 +158,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 +173,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

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

@@ -13,16 +13,26 @@ 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|
+            # If there's legitimate failures or errors, skips and slows aren't relevant
+            next unless relevant_issue_types?(hit)
 
-            next if line_number_tokens.empty?
+            @tokens << [[:muted, ""]]
+            @tokens << file_summary_tokens(hit)
 
-            @tokens << [
-              *file_tokens,
-              *line_number_tokens
-            ]
+            repeats = repeated_line_numbers(hit)
+            next unless repeats.any?
+
+            repeats.each do |line_number|
+              @tokens << [[:muted, "  Issues on Line #{line_number} initially triggered from these locations:"]]
+
+              traces = hit.lines[line_number.to_s]
+              sorted_traces = traces.sort_by { |trace| trace.locations.last.line_number }
+
+              sorted_traces.each do |trace|
+                @tokens << origination_location_token(trace)
+              end
+            end
           end
 
           @tokens
@@ -30,8 +40,26 @@ module Minitest
 
         private
 
-        def map
-          results.heat_map
+        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 +74,69 @@ 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)
+          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 repeated_line_numbers(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, right?
+            next unless traces.size > 1
+
+            repeated_line_numbers << Integer(line_number)
           end
 
-          numbers
+          repeated_line_numbers.sort
         end
 
-        def line_numbers(file)
+        def repeated_line_numbers?(hit)
+          repeated_line_numbers(hit).any?
+        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_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
+
+        def line_number_token(style, line_number)
+          [style, "#{line_number} "]
+        end
+
+        # Generates the line number tokens styled based on their error 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
+        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: '➜',
@@ -56,14 +56,14 @@ module Minitest
 
           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
+      rescue StandardError => e
         message = "Sorry, but Minitest Heat couldn't display output for a failure."
         exception_guidance(message, e)
       end
@@ -75,7 +75,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,7 +84,7 @@ 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
@@ -92,7 +92,7 @@ module Minitest
       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}"
@@ -138,7 +138,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.11'
   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)