minitest-heat 0.0.8 → 0.0.12

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,96 @@ module Minitest
         end
 
         def headline_tokens
-          [[issue.type, issue.label], spacer_token, [:default, issue.test_name]]
+          [label_token(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_token(issue)
+          [issue.type, issue_label(issue.type)]
+        end
+
+        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
 
         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 +176,6 @@ module Minitest
         def arrow_token
           Output::TOKENS[:muted_arrow]
         end
-
       end
     end
   end

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,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
@@ -29,13 +40,33 @@ 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
+          # 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 +74,75 @@ 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)
+          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)
-          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} "]
+        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)
+        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
-          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,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

@@ -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.8'
+    VERSION = '0.0.12'
   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