minitest-heat 0.0.5 → 0.0.6

data/lib/minitest/heat/location.rb

@@ -14,10 +14,18 @@ module Minitest
     #   - '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 Location
+      TestDefinition = Struct.new(:pathname, :line_number) do
+        def initialize(pathname, line_number)
+          @pathname = Pathname(pathname)
+          @line_number = Integer(line_number)
+          super
+        end
+      end
+
       attr_reader :test_location, :backtrace
 
       def initialize(test_location, backtrace = [])
-        @test_location = test_location
+        @test_location = TestDefinition.new(*test_location)
         @backtrace = Backtrace.new(backtrace)
       end
 
@@ -58,28 +66,28 @@ module Minitest
       #
       # @return [String] the relative path to the file from the project root
       def most_relevant_file
-        Pathname(most_relevant_location[0])
+        Pathname(most_relevant_location.pathname)
       end
 
       # The line number of the `most_relevant_file` where the failure originated
       #
       # @return [Integer] line number
       def most_relevant_failure_line
-        most_relevant_location[1]
+        most_relevant_location.line_number
       end
 
       # The final location of the stacktrace regardless of whether it's from within the project
       #
       # @return [String] the relative path to the file from the project root
       def final_file
-        Pathname(final_location[0])
+        Pathname(final_location.pathname)
       end
 
       # The line number of the `final_file` where the failure originated
       #
       # @return [Integer] line number
       def final_failure_line
-        final_location[1]
+        final_location.line_number
       end
 
       # The final location of the stacktrace regardless of whether it's from within the project
@@ -100,7 +108,7 @@ module Minitest
       #
       # @return [String, nil] the relative path to the file from the project root
       def source_code_file
-        return nil unless backtrace.source_code_lines.any?
+        return nil unless backtrace.source_code_entries.any?
 
         backtrace.final_source_code_location.pathname
       end
@@ -109,30 +117,30 @@ module Minitest
       #
       # @return [Integer] line number
       def source_code_failure_line
-        return nil unless backtrace.source_code_lines.any?
+        return nil unless backtrace.source_code_entries.any?
 
-        backtrace.final_source_code_location.number
+        backtrace.final_source_code_location.line_number
       end
 
       # The final location from the stacktrace that is within the project's test directory
       #
       # @return [String, nil] the relative path to the file from the project root
       def test_file
-        Pathname(test_location[0])
+        Pathname(test_location.pathname)
       end
 
       # The line number of the `test_file` where the test is defined
       #
       # @return [Integer] line number
       def test_definition_line
-        test_location[1].to_s
+        test_location.line_number
       end
 
       # The line number from within the `test_file` test definition where the failure occurred
       #
       # @return [Integer] line number
       def test_failure_line
-        backtrace.final_test_location&.number || test_definition_line
+        backtrace.final_test_location&.line_number || test_definition_line
       end
 
       # The line number from within the `test_file` test definition where the failure occurred
@@ -166,10 +174,8 @@ module Minitest
       end
 
       def backtrace?
-        backtrace.parsed_lines.any?
+        backtrace.parsed_entries.any?
       end
     end
   end
 end
-
-

data/lib/minitest/heat/map.rb

@@ -3,6 +3,8 @@
 module Minitest
   module Heat
     class Map
+      MAXIMUM_FILES_TO_SHOW = 5
+
       attr_reader :hits
 
       # So we can sort hot spots by liklihood of being the most important spot to check out before
@@ -14,44 +16,31 @@ module Minitest
       #   misleading. It doesn't represent a proper failure, but rather a test that doesn't work.
       WEIGHTS = {
         error: 3,    # exceptions from source code have the highest liklihood of a ripple effect
-        broken: 1,   # broken tests won't have ripple effects but can't help if they can't run
+        broken: 2,   # broken tests won't have ripple effects but can't help if they can't run
         failure: 1,  # failures are kind of the whole point, and they could have ripple effects
         skipped: 0,  # skips aren't failures, but they shouldn't go ignored
         painful: 0,  # slow tests aren't failures, but they shouldn't be ignored
-        slow: 0,
-      }
+        slow: 0
+      }.freeze
 
       def initialize
         @hits = {}
       end
 
       def add(filename, line_number, type)
-        @hits[filename] ||= { weight: 0, total: 0 }
-        @hits[filename][:total] += 1
-        @hits[filename][:weight] += WEIGHTS[type]
+        @hits[filename] ||= Hit.new(filename)
 
-        @hits[filename][type] ||= []
-        @hits[filename][type] << line_number
+        @hits[filename].log(type, line_number)
       end
 
-      def files
-        hot_files
-          .sort_by { |filename, weight| weight }
-          .reverse
-          .take(5)
+      def file_hits
+        hot_files.take(MAXIMUM_FILES_TO_SHOW)
       end
 
       private
 
       def hot_files
-        files = {}
-        @hits.each_pair do |filename, details|
-          # Can't really be a "hot spot" with just a single issue
-          # next unless details[:weight] > 1
-
-          files[filename] = details[:weight]
-        end
-        files
+        hits.values.sort_by(&:weight).reverse
       end
     end
   end

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

@@ -21,22 +21,18 @@ module Minitest
           # final backtrace line if it might be relevant/helpful?
 
           # Iterate over the selected lines from the backtrace
-          backtrace_lines.each do |backtrace_line|
+          backtrace_entries.each do |backtrace_entry|
             # Get the source code for the line from the backtrace
-            source_code = source_code_for(backtrace_line)
-
             parts = [
               indentation_token,
-              path_token(backtrace_line),
-              file_and_line_number_token(backtrace_line),
-              source_code_line_token(source_code)
+              path_token(backtrace_entry),
+              file_and_line_number_token(backtrace_entry),
+              source_code_line_token(backtrace_entry.source_code)
             ]
 
-            parts << file_freshness(backtrace_line) if most_recently_modified?(backtrace_line)
+            parts << file_freshness(backtrace_entry) if most_recently_modified?(backtrace_entry)
 
             @tokens << parts
-
-
           end
 
           @tokens
@@ -55,37 +51,31 @@ 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_lines
-          project_lines
+        def backtrace_entries
+          project_entries
         end
 
         private
 
-        def all_backtrace_lines_from_project?
-          backtrace_lines.all? { |line| line.path.include?(project_root_dir) }
+        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_lines
-          backtrace.project_lines.take(line_count)
+        def project_entries
+          backtrace.project_entries.take(line_count)
         end
 
-        def all_lines
-          backtrace.parsed_lines.take(line_count)
-        end
-
-        def source_code_for(line)
-          filename = "#{line.path}/#{line.file}"
-
-          Minitest::Heat::Source.new(filename, line_number: line.number, max_line_count: 1)
+        def all_entries
+          backtrace.parsed_entries.take(line_count)
         end
 
         def most_recently_modified?(line)
           # If there's more than one line being displayed, and the current line is the freshest
-          backtrace_lines.size > 1 && line == backtrace.freshest_project_location
+          backtrace_entries.size > 1 && line == backtrace.freshest_project_location
         end
 
         def indentation_token
@@ -97,21 +87,21 @@ module Minitest
 
           # 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_lines_from_project?
+          path = path.delete_prefix(project_root_dir) if all_backtrace_entries_from_project?
 
           [:muted, path]
         end
 
-        def file_and_line_number_token(backtrace_line)
-          [:default, "#{backtrace_line.file}:#{backtrace_line.number}"]
+        def file_and_line_number_token(backtrace_entry)
+          [:default, "#{backtrace_entry.file}:#{backtrace_entry.line_number}"]
         end
 
         def source_code_line_token(source_code)
           [:muted, " `#{source_code.line.strip}`"]
         end
 
-        def file_freshness(line)
-          [:bold, " < Most Recently Modified"]
+        def file_freshness(_line)
+          [:bold, ' < Most Recently Modified']
         end
 
         # The number of spaces each line of code should be indented. Currently defaults to 2 in

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

@@ -4,6 +4,11 @@ module Minitest
   module Heat
     class Output
       class Issue
+        SHARED_SYMBOLS = {
+          spacer: ' · ',
+          arrow: ' > '
+        }.freeze
+
         attr_accessor :issue
 
         def initialize(issue)
@@ -11,6 +16,111 @@ module Minitest
         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
+          end
+        end
+
+        private
+
+        def error_tokens
+          [
+            headline_tokens,
+            summary_tokens,
+            *backtrace_tokens,
+            newline_tokens
+          ]
+        end
+
+        def broken_tokens
+          [
+            headline_tokens,
+            summary_tokens,
+            *backtrace_tokens,
+            newline_tokens
+          ]
+        end
+
+        def failure_tokens
+          [
+            headline_tokens,
+            summary_tokens,
+            location_tokens,
+            *source_tokens,
+            newline_tokens
+          ]
+        end
+
+        def skipped_tokens
+          [
+            headline_tokens,
+            summary_tokens,
+            newline_tokens
+          ]
+        end
+
+        def painful_tokens
+          [
+            headline_tokens,
+            slowness_tokens,
+            newline_tokens
+          ]
+        end
+
+        def slow_tokens
+          [
+            headline_tokens,
+            slowness_tokens,
+            newline_tokens
+          ]
+        end
+
+        def headline_tokens
+          [[issue.type, issue.label], [:muted, spacer], [:default, issue.test_name], [:muted, spacer], [:muted, issue.test_class]]
+        end
+
+        def summary_tokens
+          [[:italicized, issue.summary]]
+        end
+
+        def backtrace_tokens
+          backtrace = ::Minitest::Heat::Output::Backtrace.new(issue.location)
+
+          backtrace.tokens
+        end
+
+        def location_tokens
+          [[:muted, issue.short_location]]
+        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)
+
+          source_code.tokens
+        end
+
+        def slowness_tokens
+          [[:bold, issue.slowness], [:muted, spacer], [:default, issue.short_location] ]
+        end
+
+        def newline_tokens
+          []
+        end
+
+        def spacer
+          SHARED_SYMBOLS[:spacer]
+        end
+
+        def arrow
+          SHARED_SYMBOLS[:arrow]
         end
       end
     end

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

@@ -4,16 +4,63 @@ module Minitest
   module Heat
     class Output
       class Map
+        # extend Forwardable
+
         attr_accessor :map
 
+        # def_delegators :@results, :errors, :brokens, :failures, :slows, :skips, :problems?, :slows?
+
         def initialize(map)
           @map = map
+          @tokens = []
         end
 
         def tokens
+          map.file_hits.each do |file|
+            @tokens << [
+              *pathname(file),
+              *line_numbers(file)
+            ]
+          end
+
+          @tokens
         end
 
         private
+
+        def pathname(file)
+          directory = "#{file.pathname.dirname.to_s.delete_prefix(Dir.pwd)}/"
+          filename = file.pathname.basename.to_s
+
+          [
+            [:default, directory],
+            [:bold, filename],
+            [:default, ' · ']
+          ]
+        end
+
+        def hit_line_numbers(file, issue_type)
+          line_numbers_for_issue_type = file.issues.fetch(issue_type) { [] }
+
+          return nil if line_numbers_for_issue_type.empty?
+
+          numbers = []
+          line_numbers_for_issue_type.sort.map do |line_number|
+            numbers << [issue_type, "#{line_number} "]
+          end
+          numbers
+        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] }
+        end
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    # Friendly API for printing nicely-formatted output to the console
+    class Output
+      class Marker
+        SYMBOLS = {
+          success: '·',
+          slow: '♦',
+          painful: '♦',
+          broken: 'B',
+          error: 'E',
+          skipped: 'S',
+          failure: 'F'
+        }.freeze
+
+        STYLES = {
+          success: :success,
+          slow: :slow,
+          painful: :painful,
+          broken: :error,
+          error: :error,
+          skipped: :skipped,
+          failure: :failure
+        }.freeze
+
+        attr_accessor :issue_type
+
+        def initialize(issue_type)
+          @issue_type = issue_type
+        end
+
+        def token
+          [style, symbol]
+        end
+
+        private
+
+        def style
+          STYLES.fetch(issue_type, :default)
+        end
+
+        def symbol
+          SYMBOLS.fetch(issue_type, '?')
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Minitest
 
         attr_accessor :results
 
-        def_delegators :@results, :errors, :brokens, :failures, :slows, :skips, :problems?, :slows?
+        def_delegators :@results, :errors, :brokens, :failures, :skips, :painfuls, :slows, :problems?, :slows?
 
         def initialize(results)
           @results = results
@@ -17,8 +17,8 @@ module Minitest
 
         def tokens
           @tokens << [*issue_counts_tokens] if issue_counts_tokens&.any?
-          @tokens << [assertions_count_token, test_count_token]
           @tokens << [assertions_performance_token, tests_performance_token, timing_token]
+          @tokens << [assertions_count_token, test_count_token]
 
           @tokens
         end
@@ -35,14 +35,21 @@ module Minitest
         def issue_counts_tokens
           return unless problems? || slows?
 
-          counts = [error_count_token, broken_count_token, failure_count_token, skip_count_token, slow_count_token].compact
+          counts = [
+            error_count_token,
+            broken_count_token,
+            failure_count_token,
+            skip_count_token,
+            painful_count_token,
+            slow_count_token
+          ].compact
 
           # # Create an array of separator tokens one less than the total number of issue count tokens
           separator_tokens = Array.new(counts.size, separator_token)
 
           counts_with_separators = counts
-                                    .zip(separator_tokens) # Add separators between the counts
-                                    .flatten(1) # Flatten the zipped separators, but no more
+                                   .zip(separator_tokens) # Add separators between the counts
+                                   .flatten(1) # Flatten the zipped separators, but no more
 
           counts_with_separators.pop # Remove the final trailing zipped separator that's not needed
 
@@ -66,6 +73,11 @@ module Minitest
           issue_count_token(style, skips, name: 'Skip')
         end
 
+        def painful_count_token
+          style = problems? ? :muted : :painful
+          issue_count_token(style, painfuls, name: 'Painfully Slow')
+        end
+
         def slow_count_token
           style = problems? ? :muted : :slow
           issue_count_token(style, slows, name: 'Slow')

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

@@ -101,9 +101,9 @@ module Minitest
         # @return [Array<Symbol>] the Token styles for the line number and line of code
         def styles_for(line_of_code)
           if line_of_code == source.line && highlight_key_line?
-            [:default, :default]
+            %i[default default]
           else
-            [:muted, :muted]
+            %i[muted muted]
           end
         end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Minitest
   module Heat
     # Friendly API for printing nicely-formatted output to the console
@@ -6,18 +8,18 @@ module Minitest
         class InvalidStyle < ArgumentError; end
 
         STYLES = {
-          success:       %i[default green],
-          slow:          %i[bold green],
-          painful:       %i[bold green],
-          error:         %i[bold red],
-          broken:        %i[bold red],
-          failure:       %i[default red],
-          skipped:       %i[default yellow],
+          success: %i[default green],
+          slow: %i[default green],
+          painful: %i[bold green],
+          error: %i[bold red],
+          broken: %i[bold red],
+          failure: %i[default red],
+          skipped: %i[default yellow],
           warning_light: %i[light yellow],
-          italicized:    %i[italic gray],
-          bold:          %i[bold default],
-          default:       %i[default default],
-          muted:         %i[light gray]
+          italicized: %i[italic gray],
+          bold: %i[bold default],
+          default: %i[default default],
+          muted: %i[light gray]
         }.freeze
 
         attr_accessor :style_key, :content
@@ -38,14 +40,14 @@ module Minitest
         end
 
         def eql?(other)
-          style_key == other.style_key &&  content == other.content
+          style_key == other.style_key && content == other.content
         end
         alias :== eql?
 
         private
 
         ESC_SEQUENCE = "\e["
-        END_SEQUENCE = "m"
+        END_SEQUENCE = 'm'
 
         WEIGHTS = {
           default: 0,