minitest-heat 0.0.1 → 0.0.5

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