minitest-heat 0.0.3 → 0.0.7

data/lib/minitest/heat/location.rb

@@ -2,59 +2,180 @@
 
 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' 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 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
 
+      # 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
-        "#{source_file}:#{source_failure_line}"
+        "#{most_relevant_file}:#{most_relevant_failure_line}"
+      end
+
+      def local?
+        broken_test? || proper_failure?
+      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 most relevant file is the same as the test location file
+      def broken_test?
+        !test_file.nil? && test_file == most_relevant_file
+      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_file.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 [String] the relative path to the file from the project root
+      def most_relevant_file
+        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.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.pathname)
       end
 
-      def failure_in_test?
-        !test_file.nil? && test_file == source_file
+      # The line number of the `final_file` where the failure originated
+      #
+      # @return [Integer] line number
+      def final_failure_line
+        final_location.line_number
       end
 
-      def failure_in_source?
-        !failure_in_test?
+      # 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 project_file
+        broken_test? ? test_file : source_code_file
       end
 
+      # The line number of the `project_file` where the failure originated
+      #
+      # @return [Integer] line number
+      def project_failure_line
+        broken_test? ? test_failure_line || test_definition_line : source_code_failure_line
+      end
+
+      # The final location from the stacktrace that is within the project directory
+      #
+      # @return [String, nil] the relative path to the file from the project root
+      def source_code_file
+        return nil unless backtrace.source_code_entries.any?
+
+        backtrace.final_source_code_location.pathname
+      end
+
+      # The line number of the `source_code_file` where the failure originated
+      #
+      # @return [Integer] line number
+      def source_code_failure_line
+        return nil unless backtrace.source_code_entries.any?
+
+        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
-        reduced_path(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
+        backtrace.final_test_location&.line_number || test_definition_line
       end
 
-      def source_file
-        return test_file if backtrace.empty?
-
-        source_line = backtrace.final_project_location
-
-        reduced_path("#{source_line.path}/#{source_line.file}")
+      # 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_location
+        backtrace? ? backtrace.final_location : test_location
       end
 
-      def source_failure_line
-        return test_definition_line if backtrace.empty?
+      # 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_location
+        [
+          source_code_location,
+          test_location,
+          final_location
+        ].compact.first
+      end
 
-        backtrace.final_project_location.number
+      def project_location
+        source_code_location || test_location
       end
 
-      private
+      def source_code_location
+        backtrace.final_source_code_location
+      end
 
-      def reduced_path(path)
-        path.delete_prefix(Dir.pwd)
+      def backtrace?
+        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
@@ -13,44 +15,32 @@ module Minitest
       #   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
-        slow: 0     # slow tests aren't failures, but they shouldn't be ignored
-      }
+        error: 3,    # exceptions from source code have the highest liklihood of a ripple effect
+        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
+      }.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[:total] > 1
-
-          files[filename] = details[:weight]
-        end
-        files
+        hits.values.sort_by(&:weight).reverse
       end
     end
   end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      # Builds the collection of tokens for a backtrace when an exception occurs
+      class Backtrace
+        DEFAULT_LINE_COUNT = 5
+        DEFAULT_INDENTATION_SPACES = 2
+
+        attr_accessor :location, :backtrace
+
+        def initialize(location)
+          @location = location
+          @backtrace = location.backtrace
+          @tokens = []
+        end
+
+        def tokens
+          # There could be option to expand and display more than one line of source code for the
+          # 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 = [
+              indentation_token,
+              path_token(backtrace_entry),
+              *file_and_line_number_tokens(backtrace_entry),
+              source_code_line_token(backtrace_entry.source_code)
+            ]
+
+            parts << file_freshness(backtrace_entry) if most_recently_modified?(backtrace_entry)
+
+            @tokens << parts
+          end
+
+          @tokens
+        end
+
+        def line_count
+          DEFAULT_LINE_COUNT
+        end
+
+        # This should probably be smart about what lines are displayed in a backtrace.
+        # Maybe...
+        # ...it could intelligently display the full back trace?
+        # ...only the backtrace from the first/last line of project source?
+        # ...it behaves a little different when it's a broken test vs. a true exception?
+        # ...it could be smart about subtly flagging the lines that show up in the heat map frequently?
+        # ...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
+        end
+
+        private
+
+        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)
+        end
+
+        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_entries.size > 1 && line == backtrace.freshest_project_location
+        end
+
+        def indentation_token
+          [:default, ' ' * indentation]
+        end
+
+        def path_token(line)
+          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_entries_from_project?
+
+          [:muted, path]
+        end
+
+        def file_and_line_number_tokens(backtrace_entry)
+          [[:default, backtrace_entry.file], [:muted, ':'], [:default, backtrace_entry.line_number]]
+        end
+
+        def source_code_line_token(source_code)
+          [:muted, " #{Output::SYMBOLS[:arrow]} `#{source_code.line.strip}`"]
+        end
+
+        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
+        #   order to provide visual separation between test failures, but in the future, it could
+        #   be configurable in order to save horizontal space and create more compact output. For
+        #   example, it could be smart based on line length and total available horizontal terminal
+        #   space, or there could be higher-level "display" setting that could have a `:compact`
+        #   option that would reduce the space used.
+        #
+        # @return [type] [description]
+        def indentation
+          DEFAULT_INDENTATION_SPACES
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      class Issue
+        attr_accessor :issue
+
+        def initialize(issue)
+          @issue = issue
+        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,
+            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_code = ::Minitest::Heat::Output::SourceCode.new(filename, line_number, max_line_count: 1)
+          # source_code.tokens
+
+          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.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}/")
+        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 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
+
+        def arrow_token
+          Output::TOKENS[:muted_arrow]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+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
+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