minitest-heat 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbfeed7b313b60332751ad13c01750b56452e6cac80f98346d4f7233ae807cef
-  data.tar.gz: 7a734d467343b7da882c8a5f62e1005664ea9b2ab889d766416d8f21fce2299b
+  metadata.gz: c760c15a45811d5773dee18e32aadc063ed61c3eb04447c637719d5d3d46178a
+  data.tar.gz: 90c345c56cbd2589719eef8a0264a5973f77a8104c91149f4e4ad2320067a49a
 SHA512:
-  metadata.gz: '07468b2090eef7a6475382db46e9bc150d2fc30e54d54d6744c0c12d6c33364f6d39aff6938baf4647c0e64fe7c754d0c1ad8b42aebf7b87e8edce8a1c35542f'
-  data.tar.gz: f1f961dc9bcf258d09fec7184dc0cb778d5b9fbc865ad2ed2c9d2f68628c4329990febc45b41770582826ab26576236c41657ced44c0ddb494b1b7fb71403c38
+  metadata.gz: 47be296804a2171023bfcdb5c4192376698349bd76c4c3a2991d9accd9f631b88d2ffb867d821f2479c41bd6fd2cf919af325ecde975f98ee4592277b3b09432
+  data.tar.gz: 79a180260e9a1d8c55d898883f13969f2576ceb6450dc9e080050e55674c73fc7979202a2c8a78542958491fce91fee2a3cb1b66fd2705edc4a8d432f5e28fcc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    minitest-heat (0.0.4)
+    minitest-heat (0.0.5)
       minitest
 
 GEM

data/lib/minitest/heat/backtrace.rb

@@ -6,11 +6,23 @@ module Minitest
     class Backtrace
       Line = Struct.new(:path, :file, :number, :container, :mtime, keyword_init: true) do
         def to_s
-          "#{path}/#{file}:#{line} in `#{container}` #{age_in_seconds}"
+          "#{location} in `#{container}`"
         end
 
-        def to_file
-          "#{path}/#{file}"
+        def pathname
+          Pathname("#{path}/#{file}")
+        end
+
+        def location
+          "#{pathname.to_s}:#{number}"
+        end
+
+        def short_pathname
+          pathname.delete_prefix(Dir.pwd)
+        end
+
+        def short_location
+          "#{pathname.basename.to_s}:#{number}"
         end
 
         def age_in_seconds
@@ -18,6 +30,16 @@ module Minitest
         end
       end
 
+      UNREADABLE_FILE_ATTRIBUTES = {
+        path: '(Unknown Path)',
+        file: '(Unknown File)',
+        number: '(Unknown Line Number)',
+        container: '(Unknown Method)',
+        mtime: '(Unknown Modification Time)'
+      }
+
+      UNREADABLE_LINE = Line.new(UNREADABLE_FILE_ATTRIBUTES)
+
       attr_reader :raw_backtrace
 
       def initialize(raw_backtrace)
@@ -29,37 +51,45 @@ module Minitest
       end
 
       def final_location
-        parsed.first
+        parsed_lines.first
       end
 
       def final_project_location
-        project.first
+        project_lines.first
+      end
+
+      def freshest_project_location
+        recently_modified_lines.first
+      end
+
+      def final_source_code_location
+        source_code_lines.first
       end
 
       def final_test_location
-        tests.first
+        test_lines.first
       end
 
-      def freshest_project_location
-        recently_modified.first
+      def project_lines
+        @project_lines ||= parsed_lines.select { |line| line[:path].include?(Dir.pwd) }
       end
 
-      def project
-        @project ||= parsed.select { |line| line[:path].include?(Dir.pwd) }
+      def recently_modified_lines
+        @recently_modified_lines ||= project_lines.sort_by { |line| line[:mtime] }.reverse
       end
 
-      def tests
-        @tests ||= project.select { |line| test_file?(line) }
+      def test_lines
+        @tests_lines ||= project_lines.select { |line| test_file?(line) }
       end
 
-      def recently_modified
-        @recently_modified ||= project.sort_by { |line| line[:mtime] }.reverse
+      def source_code_lines
+        @source_code_lines ||= project_lines - test_lines
       end
 
-      def parsed
+      def parsed_lines
         return [] if raw_backtrace.nil?
 
-        @parsed ||= raw_backtrace.map { |line| parse(line) }
+        @parsed_lines ||= raw_backtrace.map { |line| parse(line) }
       end
 
       private
@@ -83,6 +113,8 @@ module Minitest
           container: reduce_container(parts[2]),
           mtime: pathname.exist? ? pathname.mtime : nil
         }
+      rescue
+        UNREADABLE_FILE_ATTRIBUTES
       end
 
       def test_file?(line)

data/lib/minitest/heat/issue.rb

@@ -40,10 +40,14 @@ module Minitest
         @location = Location.new(result.source_location, @failure&.backtrace)
       end
 
+      def short_location
+        location.to_s.delete_prefix(Dir.pwd)
+      end
+
       def to_hit
         [
-          location.source_file,
-          location.source_failure_line,
+          location.project_file.to_s,
+          location.project_failure_line,
           type
         ]
       end
@@ -87,15 +91,15 @@ module Minitest
       end
 
       def in_test?
-        location.failure_in_test?
+        location.broken_test?
       end
 
       def in_source?
-        location.failure_in_source?
+        location.proper_failure?
       end
 
       def test_class
-        result.klass.delete_prefix('Minitest::')
+        result.klass
       end
 
       def test_identifier

data/lib/minitest/heat/location.rb

@@ -2,6 +2,17 @@
 
 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
       attr_reader :test_location, :backtrace
 
@@ -10,48 +21,152 @@ module Minitest
         @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 failure_in_test?
-        !test_file.nil? && test_file == source_file
+      def local?
+        broken_test? || proper_failure?
       end
 
-      def failure_in_source?
-        !failure_in_test?
+      # 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[0])
+      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]
+      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])
+      end
+
+      # The line number of the `final_file` where the failure originated
+      #
+      # @return [Integer] line number
+      def final_failure_line
+        final_location[1]
+      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 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_lines.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_lines.any?
+
+        backtrace.final_source_code_location.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[0])
       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
       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&.number || test_definition_line
       end
 
-      def source_file
-        return test_file if backtrace.empty?
-
-        source_line = backtrace.final_project_location || backtrace.final_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_lines.any?
       end
     end
   end

data/lib/minitest/heat/map.rb

@@ -47,7 +47,7 @@ module Minitest
         files = {}
         @hits.each_pair do |filename, details|
           # Can't really be a "hot spot" with just a single issue
-          next unless details[:weight] > 1
+          # next unless details[:weight] > 1
 
           files[filename] = details[:weight]
         end

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

@@ -0,0 +1,131 @@
+# 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_lines.each do |backtrace_line|
+            # 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)
+            ]
+
+            parts << file_freshness(backtrace_line) if most_recently_modified?(backtrace_line)
+
+            @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_lines
+          project_lines
+        end
+
+        private
+
+        def all_backtrace_lines_from_project?
+          backtrace_lines.all? { |line| line.path.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)
+        end
+
+        def source_code_for(line)
+          filename = "#{line.path}/#{line.file}"
+
+          Minitest::Heat::Source.new(filename, line_number: line.number, max_line_count: 1)
+        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
+        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_lines_from_project?
+
+          [:muted, path]
+        end
+
+        def file_and_line_number_token(backtrace_line)
+          [:default, "#{backtrace_line.file}:#{backtrace_line.number}"]
+        end
+
+        def source_code_line_token(source_code)
+          [:muted, " `#{source_code.line.strip}`"]
+        end
+
+        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
+        #   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,18 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      class Issue
+        attr_accessor :issue
+
+        def initialize(issue)
+          @issue = issue
+        end
+
+        def tokens
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      class Location
+        attr_accessor :location
+
+        def initialize(location)
+          @location = location
+        end
+
+        def tokens
+        end
+
+        private
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      class Map
+        attr_accessor :map
+
+        def initialize(map)
+          @map = map
+        end
+
+        def tokens
+        end
+
+        private
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      class Results
+        extend Forwardable
+
+        attr_accessor :results
+
+        def_delegators :@results, :errors, :brokens, :failures, :slows, :skips, :problems?, :slows?
+
+        def initialize(results)
+          @results = results
+          @tokens = []
+        end
+
+        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
+        end
+
+        private
+
+        def pluralize(count, singular)
+          singular_style = "#{count} #{singular}"
+
+          # Given the narrow scope, pluralization can be relatively naive here
+          count > 1 ? "#{singular_style}s" : singular_style
+        end
+
+        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
+
+          # # 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
+
+          counts_with_separators.pop # Remove the final trailing zipped separator that's not needed
+
+          counts_with_separators
+        end
+
+        def error_count_token
+          issue_count_token(:error, errors)
+        end
+
+        def broken_count_token
+          issue_count_token(:broken, brokens)
+        end
+
+        def failure_count_token
+          issue_count_token(:failure, failures)
+        end
+
+        def skip_count_token
+          style = problems? ? :muted : :skipped
+          issue_count_token(style, skips, name: 'Skip')
+        end
+
+        def slow_count_token
+          style = problems? ? :muted : :slow
+          issue_count_token(style, slows, name: 'Slow')
+        end
+
+        def assertions_performance_token
+          [:bold, "#{results.assertions_per_second} assertions/s"]
+        end
+
+        def tests_performance_token
+          [:default, " and #{results.tests_per_second} tests/s"]
+        end
+
+        def timing_token
+          [:default, " in #{results.total_time.round(2)}s"]
+        end
+
+        def assertions_count_token
+          [:muted, pluralize(results.assertion_count, 'Assertion')]
+        end
+
+        def test_count_token
+          [:muted, " across #{pluralize(results.test_count, 'Test')}"]
+        end
+
+        def issue_count_token(type, collection, name: type.capitalize)
+          return nil if collection.empty?
+
+          [type, pluralize(collection.size, name)]
+        end
+
+        def separator_token
+          [:muted, ' · ']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      # Builds the collection of tokens representing a specific set of source code lines
+      class SourceCode
+        DEFAULT_LINE_COUNT = 3
+        DEFAULT_INDENTATION_SPACES = 2
+        HIGHLIGHT_KEY_LINE = true
+
+        attr_reader :filename, :line_number, :max_line_count
+
+        # Provides a collection of tokens representing the output of source code
+        # @param filename [String] the absolute path to the file containing the source code
+        # @param line_number [Integer, String] the primary line number of interest for the file
+        # @param max_line_count: DEFAULT_LINE_COUNT [Integer] maximum total number of lines to
+        #   retrieve around the target line (including the target line)
+        #
+        # @return [self]
+        def initialize(filename, line_number, max_line_count: DEFAULT_LINE_COUNT)
+          @filename = filename
+          @line_number = line_number.to_s
+          @max_line_count = max_line_count
+          @tokens = []
+        end
+
+        # The collection of style content tokens to print
+        #
+        # @return [Array<Array<Token>>] an array of arrays of tokens where each top-level array
+        #   represents a line where the first element is the line_number and the second is the line
+        #   of code to display
+        def tokens
+          source.lines.each_index do |i|
+            current_line_number  = source.line_numbers[i]
+            current_line_of_code = source.lines[i]
+
+            number_style, line_style = styles_for(current_line_of_code)
+
+            @tokens << [
+              line_number_token(number_style, current_line_number),
+              line_of_code_token(line_style, current_line_of_code)
+            ]
+          end
+          @tokens
+        end
+
+        # The number of digits for the largest line number returned. This is used for formatting and
+        #   text justification so that line numbers are right-aligned
+        #
+        # @return [Integer] the number of digits in the longest line number returned
+        def max_line_number_digits
+          source
+            .line_numbers
+            .map(&:to_s)
+            .map(&:length)
+            .max
+        end
+
+        # Whether to visually highlight the target line when displaying the source code. Currently
+        #   defauls to true, but long-term, this is a likely candidate to be configurable. For
+        #   example, in the future, highlighting could only be used if the source includes more than
+        #   three lines. Or it could be something end users could disable in order to reduce noise.
+        #
+        # @return [Boolean] true if the target line should be highlighted
+        def highlight_key_line?
+          HIGHLIGHT_KEY_LINE
+        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
+
+        private
+
+        # The source instance for retrieving the relevant lines of source code
+        #
+        # @return [Source] a Minitest::Heat::Source instance
+        def source
+          @source ||= Minitest::Heat::Source.new(
+            filename,
+            line_number: line_number,
+            max_line_count: max_line_count
+          )
+        end
+
+        # Determines how to style a given line of code token. For now, it's only used for
+        #   highlighting the targeted line of code, but it could also be adjusted to mute the line
+        #   number or otherwise change the styling of how lines of code are displayed
+        # @param line_of_code [String] the content representing the line of code we're currently
+        #   generating a token for
+        #
+        # @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]
+          else
+            [:muted, :muted]
+          end
+        end
+
+        # The token representing a given line number. Adds the appropriate indention and
+        #   justification to right align the line numbers
+        # @param style [Symbol] the symbol representing the style for the line number token
+        # @param line_number [Integer,String] the digits representing the line number
+        #
+        # @return [Array] the style/content token for the current line number
+        def line_number_token(style, line_number)
+          [style, "#{' ' * indentation}#{line_number.to_s.rjust(max_line_number_digits)} "]
+        end
+
+        # The token representing the content of a given line of code.
+        # @param style [Symbol] the symbol representing the style for the line of code token
+        # @param line_number [Integer,String] the content of the line of code
+        #
+        # @return [Array] the style/content token for the current line of code
+        def line_of_code_token(style, line_of_code)
+          [style, line_of_code]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module Minitest
+  module Heat
+    # Friendly API for printing nicely-formatted output to the console
+    class Output
+      class Token
+        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],
+          warning_light: %i[light yellow],
+          italicized:    %i[italic gray],
+          bold:          %i[bold default],
+          default:       %i[default default],
+          muted:         %i[light gray]
+        }.freeze
+
+        attr_accessor :style_key, :content
+
+        def initialize(style_key, content)
+          @style_key = style_key
+          @content = content
+        end
+
+        def to_s(format = :styled)
+          return content unless format == :styled
+
+          [
+            style_string,
+            content,
+            reset_string
+          ].join
+        end
+
+        def eql?(other)
+          style_key == other.style_key &&  content == other.content
+        end
+        alias :== eql?
+
+        private
+
+        ESC_SEQUENCE = "\e["
+        END_SEQUENCE = "m"
+
+        WEIGHTS = {
+          default: 0,
+          bold: 1,
+          light: 2,
+          italic: 3
+        }.freeze
+
+        COLORS = {
+          black: 30,
+          red: 31,
+          green: 32,
+          yellow: 33,
+          blue: 34,
+          magenta: 35,
+          cyan: 36,
+          gray: 37,
+          default: 39
+        }.freeze
+
+        def style_string
+          "#{ESC_SEQUENCE}#{weight};#{color}#{END_SEQUENCE}"
+        end
+
+        def reset_string
+          "#{ESC_SEQUENCE}0#{END_SEQUENCE}"
+        end
+
+        def weight_key
+          style_components[0]
+        end
+
+        def color_key
+          style_components[1]
+        end
+
+        def weight
+          WEIGHTS.fetch(weight_key)
+        end
+
+        def color
+          COLORS.fetch(color_key)
+        end
+
+        def style_components
+          STYLES.fetch(style_key) { raise InvalidStyle, "'#{style_key}' is not a valid style option for tokens" }
+        end
+      end
+    end
+  end
+end

data/lib/minitest/heat/output.rb

@@ -1,102 +1,41 @@
 # frozen_string_literal: true
 
+require_relative 'output/backtrace'
+require_relative 'output/issue'
+require_relative 'output/location'
+require_relative 'output/map'
+require_relative 'output/results'
+require_relative 'output/source_code'
+require_relative 'output/token'
+
 module Minitest
   module Heat
     # Friendly API for printing nicely-formatted output to the console
     class Output
-      ESC = "\e["
-
-      Token = Struct.new(:style, :content) do
-        def to_s
-          [
-            style_string,
-            content,
-            reset_string
-          ].join
-        end
-
-        private
-
-        def style_string
-          "#{ESC}#{weight};#{color}m"
-        end
-
-        def reset_string
-          "#{ESC}0m"
-        end
-
-        def weight_key
-          style_components[0]
-        end
-
-        def color_key
-          style_components[1]
-        end
-
-        def weight
-          {
-            default: 0,
-            bold: 1,
-            light: 2,
-            italic: 3
-          }.fetch(weight_key)
-        end
-
-        def color
-          {
-            black: 30,
-            red: 31,
-            green: 32,
-            yellow: 33,
-            blue: 34,
-            magenta: 35,
-            cyan: 36,
-            gray: 37,
-            default: 39
-          }.fetch(color_key)
-        end
-
-        def style_components
-          {
-            success: %i[default green],
-            slow: %i[bold green],
-            error: %i[bold red],
-            broken: %i[bold red],
-            failure: %i[default red],
-            skipped: %i[default yellow],
-            warning_light: %i[light yellow],
-            source: %i[italic default],
-            bold: %i[bold default],
-            default: %i[default default],
-            muted: %i[light gray]
-          }.fetch(style)
-        end
-      end
-
       FORMATTERS = {
         error: [
-          [ %i[error label], %i[muted arrow], %i[default test_name] ],
-          [ %i[default summary], ],
+          [ %i[error label], %i[muted spacer], %i[default test_name] ],
+          [ %i[italicized summary], ],
           [ %i[default backtrace_summary] ],
         ],
         broken: [
-          [ %i[broken label], %i[muted spacer], %i[default test_class], %i[muted arrow], %i[default test_name] ],
-          [ %i[default summary], ],
+          [ %i[broken label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[muted test_class] ],
+          [ %i[italicized summary], ],
           [ %i[default backtrace_summary] ],
         ],
         failure: [
-          [ %i[failure label], %i[muted spacer], %i[default test_class], %i[muted arrow], %i[default test_name], %i[muted spacer], %i[muted class] ],
-          [ %i[default summary] ],
-          [ %i[muted location], ],
+          [ %i[failure label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[muted test_class] ],
+          [ %i[italicized summary] ],
+          [ %i[muted short_location], ],
           [ %i[default source_summary], ],
         ],
         skipped: [
-          [ %i[skipped label], %i[muted spacer], %i[default test_class], %i[muted arrow], %i[default test_name] ],
-          [ %i[default summary] ],
+          [ %i[skipped label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[muted test_class] ],
+          [ %i[italicized summary] ],
           [], # New Line
         ],
         slow: [
-          [ %i[slow label], %i[muted spacer], %i[default test_class], %i[muted arrow], %i[default test_name], %i[muted spacer], %i[muted class], ],
+          [ %i[slow label], %i[muted spacer], %i[default test_name], %i[muted spacer], %i[default test_class] ],
           [ %i[bold slowness], %i[muted spacer], %i[default location], ],
           [], # New Line
         ]
@@ -120,6 +59,9 @@ module Minitest
       end
       alias newline puts
 
+      # TOOD: Convert to output class
+      #       - This should likely live in the output/issue class
+      #       - Add a 'fail_fast' option that shows the issue as soon as the failure occurs
       def marker(value)
         case value
         when 'E' then text(:error, value)
@@ -130,6 +72,9 @@ module Minitest
         end
       end
 
+      # TOOD: Convert to output class
+      #       - This should likely live in the output/issue class
+      #       - There may be justification for creating different "strategies" for the various types
       def issue_details(issue)
         formatter = FORMATTERS[issue.type]
 
@@ -150,23 +95,31 @@ module Minitest
         end
       end
 
+      # TOOD: Convert to output class
       def heat_map(map)
-        # text(:default, "🔥 Hot Spots 🔥\n")
         map.files.each do |file|
-          file = file[0]
-          values = map.hits[file]
+          pathname = Pathname(file[0])
+
+          path = pathname.dirname.to_s
+          filename = pathname.basename.to_s
+
+          values = map.hits[pathname.to_s]
 
-          filename = file.split('/').last
-          path = file.delete_suffix(filename)
 
-          text(:error, 'E' * values[:error].size) if values[:error]&.any?
-          text(:broken, 'B' * values[:broken].size) if values[:broken]&.any?
+          text(:error, 'E' * values[:error].size)     if values[:error]&.any?
+          text(:broken, 'B' * values[:broken].size)   if values[:broken]&.any?
           text(:failure, 'F' * values[:failure].size) if values[:failure]&.any?
-          text(:skipped, 'S' * values[:skipped].size) if values[:skipped]&.any?
-          text(:muted, ' ') if values[:error]&.any? || values[:broken]&.any? || values[:failure]&.any? || values[:skipped]&.any?
 
-          text(:muted, "#{path.delete_prefix('/')}")
-          text(:default, "#{filename}")
+          unless values[:error]&.any? || values[:broken]&.any? || values[:failure]&.any?
+            text(:skipped, 'S' * values[:skipped].size) if values[:skipped]&.any?
+            text(:painful, '—' * values[:painful].size) if values[:painful]&.any?
+            text(:slow, '–' * values[:slow].size)       if values[:slow]&.any?
+          end
+
+          text(:muted, ' ') if map.hits.any?
+
+          text(:muted, "#{path.delete_prefix(Dir.pwd)}/")
+          text(:default, filename)
 
           text(:muted, ':')
 
@@ -180,96 +133,56 @@ module Minitest
         newline
       end
 
-      def compact_summary(results)
-        error_count = results.errors.size
-        broken_count = results.brokens.size
-        failure_count = results.failures.size
-        slow_count = results.slows.size
-        skip_count = results.skips.size
-
-        counts = []
-        counts << pluralize(error_count, 'Error') if error_count.positive?
-        counts << pluralize(broken_count, 'Broken') if broken_count.positive?
-        counts << pluralize(failure_count, 'Failure') if failure_count.positive?
-        counts << pluralize(skip_count, 'Skip') if skip_count.positive?
-        counts << pluralize(slow_count, 'Slow') if slow_count.positive?
-        text(:default, counts.join(', '))
-
-        newline
-        text(:muted, "#{results.tests_per_second} tests/s and #{results.assertions_per_second} assertions/s ")
+      # TOOD: Convert to output class
+      def test_name_summary(issue)
+        text(:default, "#{issue.test_class} > #{issue.test_name}")
+      end
 
-        newline
-        text(:muted, pluralize(results.test_count, 'Test') + ' & ')
-        text(:muted, pluralize(results.assertion_count, 'Assertion'))
-        text(:muted, " in #{results.total_time.round(2)}s")
+      def compact_summary(results)
+        results_tokens = ::Minitest::Heat::Output::Results.new(results).tokens
 
         newline
+        print_tokens(results_tokens)
         newline
       end
 
-      private
-
-      def test_name_summary(issue)
-        text(:default, "#{issue.test_class} > #{issue.test_name}")
-      end
-
       def backtrace_summary(issue)
-        backtrace_lines = issue.backtrace.project
-
-        backtrace_line = backtrace_lines.first
-        filename = "#{backtrace_line.path.delete_prefix(Dir.pwd)}/#{backtrace_line.file}"
-
-        backtrace_lines.take(3).each do |line|
-          source = Minitest::Heat::Source.new(filename, line_number: line.number, max_line_count: 1)
+        location = issue.location
 
-          text(:muted, "  #{line.path.delete_prefix("#{Dir.pwd}/")}/")
-          text(:muted, "#{line.file}:#{line.number}")
-          text(:source, " `#{source.line.strip}`")
-
-          newline
-        end
+        backtrace_tokens = ::Minitest::Heat::Output::Backtrace.new(location).tokens
+        print_tokens(backtrace_tokens)
       end
 
       def source_summary(issue)
-        filename = issue.location.source_file
-        line_number = issue.location.source_failure_line
+        filename    = issue.location.project_file
+        line_number = issue.location.project_failure_line
 
-        source = Minitest::Heat::Source.new(filename, line_number: line_number, max_line_count: 3)
-        show_source(source, highlight_line: true, indentation: 2)
+        source_code_tokens = ::Minitest::Heat::Output::SourceCode.new(filename, line_number).tokens
+        print_tokens(source_code_tokens)
       end
 
-      def show_source(source, indentation: 0, highlight_line: false)
-        max_line_number_length = source.line_numbers.map(&:to_s).map(&:length).max
-        source.lines.each_index do |i|
-          line_number = source.line_numbers[i]
-          line = source.lines[i]
-
-          number_style, line_style = if line == source.line && highlight_line
-                                       [:default, :default]
-                                     else
-                                       [:muted, :muted]
-                                     end
-          text(number_style, "#{' ' * indentation}#{line_number.to_s.rjust(max_line_number_length)} ")
-          text(line_style, line)
-          puts
-        end
-      end
+      private
 
       def style_enabled?
         stream.tty?
       end
 
-      def pluralize(count, singular)
-        singular_style = "#{count} #{singular}"
-
-        # Given the narrow scope, pluralization can be relatively naive here
-        count > 1 ? "#{singular_style}s" : singular_style
+      def text(style, content)
+        token = Token.new(style, content)
+        print token.to_s(token_format)
       end
 
-      def text(style, content)
-        formatted_content = style_enabled? ? Token.new(style, content).to_s : content
+      def token_format
+        style_enabled? ? :styled : :unstyled
+      end
 
-        print formatted_content
+      def print_tokens(lines_of_tokens)
+        lines_of_tokens.each do |tokens|
+          tokens.each do |token|
+            print Token.new(*token).to_s(token_format)
+          end
+          newline
+        end
       end
     end
   end

data/lib/minitest/heat/results.rb

@@ -93,6 +93,10 @@ module Minitest
         skips.any?
       end
 
+      def slows?
+        slows.any?
+      end
+
       def record(issue)
         @test_count += 1
         @assertion_count += issue.result.assertions

data/lib/minitest/heat/source.rb

@@ -51,10 +51,15 @@ module Minitest
       #
       # @return [type] [description]
       def file_lines
-        @raw_lines ||= File.readlines("#{Dir.pwd}#{filename}", chomp: true)
+        @raw_lines ||= File.readlines(filename, chomp: true)
         @raw_lines.pop while @raw_lines.last.strip.empty?
 
         @raw_lines
+      rescue Errno::ENOENT
+        # Occasionally, for a variety of reasons, a file can't be read. In those cases, it's best to
+        # return no source code lines rather than have the test suite raise an error unrelated to
+        # the code being tested becaues that gets confusing.
+        []
       end
 
       private

data/lib/minitest/heat/version.rb

@@ -1,5 +1,5 @@
 module Minitest
   module Heat
-    VERSION = "0.0.4"
+    VERSION = "0.0.5"
   end
 end

data/lib/minitest/heat_reporter.rb

@@ -62,7 +62,6 @@ module Minitest
       issue = Heat::Issue.new(result)
 
       @results.record(issue)
-
       @map.add(*issue.to_hit) if issue.hit?
 
       output.marker(issue.marker)
@@ -92,7 +91,6 @@ module Minitest
       results.errors.each { |issue| output.issue_details(issue) }
 
       output.compact_summary(results)
-
       output.heat_map(map)
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-heat
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Garrett Dimon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-31 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -90,6 +90,13 @@ files:
 - lib/minitest/heat/location.rb
 - lib/minitest/heat/map.rb
 - lib/minitest/heat/output.rb
+- lib/minitest/heat/output/backtrace.rb
+- lib/minitest/heat/output/issue.rb
+- lib/minitest/heat/output/location.rb
+- lib/minitest/heat/output/map.rb
+- lib/minitest/heat/output/results.rb
+- lib/minitest/heat/output/source_code.rb
+- lib/minitest/heat/output/token.rb
 - lib/minitest/heat/results.rb
 - lib/minitest/heat/source.rb
 - lib/minitest/heat/version.rb