minitest-heat 0.0.5 → 0.0.9

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,55 +3,28 @@
 module Minitest
   module Heat
     class Map
-      attr_reader :hits
+      MAXIMUM_FILES_TO_SHOW = 5
 
-      # So we can sort hot spots by liklihood of being the most important spot to check out before
-      #   trying to fix something. These are ranked based on the possibility they represent ripple
-      #   effects where fixing one problem could potentially fix multiple other failures.
-      #
-      #   For example, if there's an exception in the file, start there. Broken code can't run. If a
-      #   test is broken (i.e. raising an exception), that's a special sort of failure that would be
-      #   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
-        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,
-      }
+      attr_reader :hits
 
       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

@@ -5,7 +5,7 @@ module Minitest
     class Output
       # Builds the collection of tokens for a backtrace when an exception occurs
       class Backtrace
-        DEFAULT_LINE_COUNT = 5
+        DEFAULT_LINE_COUNT = 10
         DEFAULT_INDENTATION_SPACES = 2
 
         attr_accessor :location, :backtrace
@@ -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_tokens(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
+          all_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)
-        end
-
-        def all_lines
-          backtrace.parsed_lines.take(line_count)
+        def project_entries
+          backtrace.project_entries.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
@@ -93,25 +83,31 @@ module Minitest
         end
 
         def path_token(line)
+          style = line.to_s.include?(Dir.pwd) ? :default : :muted
           path = "#{line.path}/"
 
           # 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]
+          [style, path]
         end
 
-        def file_and_line_number_token(backtrace_line)
-          [:default, "#{backtrace_line.file}:#{backtrace_line.number}"]
+        def file_and_line_number_tokens(backtrace_entry)
+          style = backtrace_entry.to_s.include?(Dir.pwd) ? :bold : :muted
+          [
+            [style, backtrace_entry.file],
+            [:muted, ':'],
+            [style, backtrace_entry.line_number]
+          ]
         end
 
         def source_code_line_token(source_code)
-          [:muted, " `#{source_code.line.strip}`"]
+          [:muted, " #{Output::SYMBOLS[:arrow]} `#{source_code.line.strip}`"]
         end
 
-        def file_freshness(line)
-          [:bold, " < Most Recently Modified"]
+        def file_freshness(_line)
+          [:default, " #{Output::SYMBOLS[:middot]} Most Recently Modified File"]
         end
 
         # The number of spaces each line of code should be indented. Currently defaults to 2 in
@@ -125,6 +121,10 @@ module Minitest
         def indentation
           DEFAULT_INDENTATION_SPACES
         end
+
+        def style_for(path)
+          style = path.to_s.include?(Dir.pwd) ? :default : :muted
+        end
       end
     end
   end

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

@@ -11,7 +11,151 @@ 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,
+            test_location_tokens,
+            summary_tokens,
+            *backtrace_tokens,
+            newline_tokens
+          ]
+        end
+
+        def broken_tokens
+          [
+            headline_tokens,
+            test_location_tokens,
+            summary_tokens,
+            *backtrace_tokens,
+            newline_tokens
+          ]
+        end
+
+        def failure_tokens
+          [
+            headline_tokens,
+            test_location_tokens,
+            summary_tokens,
+            newline_tokens
+          ]
+        end
+
+        def skipped_tokens
+          [
+            headline_tokens,
+            test_location_tokens,
+            newline_tokens
+          ]
+        end
+
+        def painful_tokens
+          [
+            headline_tokens,
+            slowness_summary_tokens,
+            newline_tokens
+          ]
+        end
+
+        def slow_tokens
+          [
+            headline_tokens,
+            slowness_summary_tokens,
+            newline_tokens
+          ]
+        end
+
+        def headline_tokens
+          [[issue.type, issue.label], spacer_token, [:default, issue.test_name]]
+        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]]
+        end
+
+        def location_tokens
+          [[:default, most_relevant_short_location], [:muted, ':'], [:default, issue.location.most_relevant_failure_line], [:muted, most_relevant_line_source]]
+        end
+
+        def source_tokens
+          filename    = issue.location.project_file
+          line_number = issue.location.project_failure_line
+
+          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("---------------")]]
+        end
+
+        def slowness_summary_tokens
+          [
+            [:bold, issue.slowness],
+            spacer_token,
+            [:default, issue.location.test_file.to_s.delete_prefix(Dir.pwd)],
+            [:muted, ':'],
+            [:default, issue.location.test_definition_line]
+          ]
+        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}/")
+        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
+
+        def arrow_token
+          Output::TOKENS[:muted_arrow]
+        end
+
       end
     end
   end

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

@@ -4,16 +4,72 @@ module Minitest
   module Heat
     class Output
       class Map
-        attr_accessor :map
+        attr_accessor :results
 
-        def initialize(map)
-          @map = map
+        def initialize(results)
+          @results = results
+          @tokens = []
         end
 
         def tokens
+          map.file_hits.each do |hit|
+            file_tokens = pathname(hit)
+            line_number_tokens = line_numbers(hit)
+
+            next if line_number_tokens.empty?
+
+            @tokens << [
+              *file_tokens,
+              *line_number_tokens
+            ]
+          end
+
+          @tokens
         end
 
         private
+
+        def map
+          results.heat_map
+        end
+
+        def relevant_issue_types
+          issue_types = %i[error broken failure]
+
+          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 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)
+          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} "]
+          end
+          numbers
+        end
+
+        def line_numbers(file)
+          line_number_tokens = []
+          relevant_issue_types.each do |issue_type|
+            line_number_tokens += hit_line_numbers(file, issue_type)
+          end
+          line_number_tokens.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