minitest-heat 0.0.7 → 0.0.11

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

@@ -3,11 +3,13 @@
 module Minitest
   module Heat
     class Output
-      class Issue
-        attr_accessor :issue
+      # Formats issues to output based on the issue type
+      class Issue # rubocop:disable Metrics/ClassLength
+        attr_accessor :issue, :locations
 
         def initialize(issue)
           @issue = issue
+          @locations = issue.locations
         end
 
         def tokens
@@ -27,7 +29,6 @@ module Minitest
           [
             headline_tokens,
             test_location_tokens,
-            location_tokens,
             summary_tokens,
             *backtrace_tokens,
             newline_tokens
@@ -78,93 +79,100 @@ module Minitest
         end
 
         def headline_tokens
-          [[issue.type, issue.label], spacer_token, [:default, issue.test_name]]
+          [[issue.type, label(issue)], spacer_token, [:default, test_name(issue)]]
+        end
+
+        def test_name(issue)
+          test_prefix = 'test_'
+          identifier = issue.test_identifier
+
+          if identifier.start_with?(test_prefix)
+            identifier.delete_prefix(test_prefix).gsub('_', ' ').capitalize
+          else
+            identifier
+          end
+        end
+
+        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
+            # 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
         end
 
         def test_name_and_class_tokens
-          [[:default, issue.test_class], *test_location_tokens ]
+          [[:default, issue.test_class], *test_location_tokens]
         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
-
-          # source_code = ::Minitest::Heat::Output::SourceCode.new(filename, line_number, max_line_count: 1)
-          # source_code.tokens
-
+          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
 
         def summary_tokens
-          [[:italicized, issue.summary.delete_suffix("---------------")]]
+          [[:italicized, issue.summary.delete_suffix('---------------').strip]]
         end
 
         def slowness_summary_tokens
-          [[:bold, issue.slowness], spacer_token, [:default, issue.short_location]]
-        end
-
-        def newline_tokens
-          []
-        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}/")
+          [
+            [:bold, slowness(issue)],
+            spacer_token,
+            [:default, locations.test_definition.relative_path],
+            [:default, locations.test_definition.filename],
+            [:muted, ':'],
+            [:default, locations.test_definition.line_number]
+          ]
         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}"
+        def slowness(issue)
+          "#{issue.execution_time.round(2)}s"
         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}"
+        def newline_tokens
+          []
         end
 
-
-        # def failure_summary_tokens
-        #   return unless issue_summary_lines.any?
-
-        #   # Sometimes, the exception message is multiple lines, so this adjusts the lines to
-        #   # visually group them together a bit
-        #   if issue_summary_lines.one?
-        #     [[[:italicized, issue_summary_lines.first]]]
-        #   else
-        #     issue_summary_lines.map do |line|
-        #       [Output::TOKENS[:muted_lead], [:italicized, line]]
-        #     end
-        #   end
-        # end
-
-        # def issue_summary_lines
-        #   @issue_summary_lines ||= issue.summary.split("\n")
-        # end
-
         def spacer_token
           Output::TOKENS[:spacer]
         end
@@ -172,7 +180,6 @@ module Minitest
         def arrow_token
           Output::TOKENS[:muted_arrow]
         end
-
       end
     end
   end

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

@@ -3,24 +3,36 @@
 module Minitest
   module Heat
     class Output
+      # Generates the tokens to output the resulting heat map
       class Map
-        # extend Forwardable
+        attr_accessor :results
 
-        attr_accessor :map
-
-        # def_delegators :@results, :errors, :brokens, :failures, :slows, :skips, :problems?, :slows?
-
-        def initialize(map)
-          @map = map
+        def initialize(results)
+          @results = results
           @tokens = []
         end
 
         def tokens
-          map.file_hits.each do |file|
-            @tokens << [
-              *pathname(file),
-              *line_numbers(file)
-            ]
+          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)
+
+            @tokens << [[:muted, ""]]
+            @tokens << file_summary_tokens(hit)
+
+            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
@@ -28,38 +40,109 @@ module Minitest
 
         private
 
-        def pathname(file)
-          directory = "#{file.pathname.dirname.to_s.delete_prefix(Dir.pwd)}/"
-          filename = file.pathname.basename.to_s
+        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?
+
+          issue_types
+        end
+
+        def relevant_issue_types?(hit)
+          intersection_issue_types = relevant_issue_types & hit.issues.keys
+
+          intersection_issue_types.any?
+        end
+
+        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
+
+          repeated_line_numbers.sort
+        end
+
+        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],
+            [:default, "#{directory}/"],
             [:bold, filename],
             [:default, ' · ']
           ]
         end
 
-        def hit_line_numbers(file, issue_type)
-          line_numbers_for_issue_type = file.issues.fetch(issue_type) { [] }
+        def line_number_tokens_for_hit(hit)
+          line_number_tokens = []
 
-          return nil if line_numbers_for_issue_type.empty?
+          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) { [] }
 
-          numbers = []
-          line_numbers_for_issue_type.sort.map do |line_number|
-            numbers << [issue_type, "#{line_number} "]
+            # 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)
-          [
-            *hit_line_numbers(file, :error),
-            *hit_line_numbers(file, :broken),
-            *hit_line_numbers(file, :failure),
-            *hit_line_numbers(file, :skipped),
-            *hit_line_numbers(file, :painful),
-            *hit_line_numbers(file, :slow)
-          ].compact.sort_by { |number_token| number_token[1] }
+        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_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
         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,30 @@ 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 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 failure."
+        exception_guidance(message, e)
       end
 
       def marker(issue_type)
@@ -53,15 +75,49 @@ 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
+
+      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
@@ -82,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

@@ -4,14 +4,36 @@ module Minitest
   module Heat
     # A collection of test failures
     class Results
-      attr_reader :issues
+      attr_reader :issues, :heat_map
 
       def initialize
         @issues = []
+        @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)
-        @issues << issue
+        # Record everything—even if it's a success
+        @issues.push(issue)
+
+        # 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?
@@ -35,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.7'
+    VERSION = '0.0.11'
   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.