minitest-heat 0.0.2 → 0.0.6

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Output
+      class Results
+        extend Forwardable
+
+        attr_accessor :results
+
+        def_delegators :@results, :errors, :brokens, :failures, :skips, :painfuls, :slows, :problems?, :slows?
+
+        def initialize(results)
+          @results = results
+          @tokens = []
+        end
+
+        def tokens
+          @tokens << [*issue_counts_tokens] if issue_counts_tokens&.any?
+          @tokens << [assertions_performance_token, tests_performance_token, timing_token]
+          @tokens << [assertions_count_token, test_count_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,
+            painful_count_token,
+            slow_count_token
+          ].compact
+
+          # # Create an array of separator tokens one less than the total number of issue count tokens
+          separator_tokens = Array.new(counts.size, separator_token)
+
+          counts_with_separators = counts
+                                   .zip(separator_tokens) # Add separators between the counts
+                                   .flatten(1) # Flatten the zipped separators, but no more
+
+          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 painful_count_token
+          style = problems? ? :muted : :painful
+          issue_count_token(style, painfuls, name: 'Painfully Slow')
+        end
+
+        def slow_count_token
+          style = problems? ? :muted : :slow
+          issue_count_token(style, slows, name: 'Slow')
+        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?
+            %i[default default]
+          else
+            %i[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,101 @@
+# frozen_string_literal: true
+
+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[default green],
+          painful: %i[bold green],
+          error: %i[bold red],
+          broken: %i[bold red],
+          failure: %i[default red],
+          skipped: %i[default yellow],
+          warning_light: %i[light yellow],
+          italicized: %i[italic gray],
+          bold: %i[bold default],
+          default: %i[default default],
+          muted: %i[light gray]
+        }.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,99 +1,17 @@
 # frozen_string_literal: true
 
+require_relative 'output/backtrace'
+require_relative 'output/issue'
+require_relative 'output/map'
+require_relative 'output/marker'
+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
-      Token = Struct.new(:style, :content) do
-        STYLES = {
-          error:   %i[bold red],
-          broken:  %i[bold red],
-          failure: %i[default red],
-          skipped: %i[bold yellow],
-          success: %i[default green],
-          slow:    %i[bold green],
-          source:  %i[italic default],
-          bold:    %i[bold default],
-          default: %i[default default],
-          subtle:  %i[light white],
-          muted:   %i[light gray],
-        }.freeze
-
-        WEIGHTS = {
-          default: 0,
-          bold: 1,
-          light: 2,
-          italic: 3,
-          underline: 4,
-          frame: 51,
-          encircle: 52,
-          overline: 53,
-        }.freeze
-
-        COLORS = {
-          black: 30,
-          red: 31,
-          green: 32,
-          yellow: 33,
-          blue: 34,
-          magenta: 35,
-          cyan: 36,
-          gray: 37, white: 97,
-          default: 39,
-        }.freeze
-
-        def to_s
-          "\e[#{weight};#{color}m#{content}#{reset}"
-        end
-
-        private
-
-        def weight
-          WEIGHTS.fetch(style_components[0])
-        end
-
-        def color
-          COLORS.fetch(style_components[1])
-        end
-
-        def reset
-          "\e[0m"
-        end
-
-        def style_components
-          STYLES[style]
-        end
-      end
-
-      FORMATTERS = {
-        error: [
-          [ %i[error label], %i[muted spacer], %i[error class], %i[muted arrow], %i[error test_name] ],
-          [ %i[default summary], ],
-          [ %i[default backtrace_summary] ],
-        ],
-        broken: [
-          [ %i[broken label], %i[muted spacer], %i[broken test_class], %i[muted arrow], %i[broken test_name] ],
-          [ %i[default summary], ],
-          [ %i[default backtrace_summary] ],
-        ],
-        failure: [
-          [ %i[failure label], %i[muted spacer], %i[failure test_class], %i[muted arrow], %i[failure test_name], %i[muted spacer], %i[muted class] ],
-          [ %i[default summary] ],
-          [ %i[subtle location], ],
-          [ %i[default source_summary], ],
-        ],
-        skipped: [
-          [ %i[skipped label], %i[muted spacer], %i[skipped test_class], %i[muted arrow], %i[skipped test_name] ],
-          [ %i[default summary], %i[muted spacer], %i[default class] ],
-          [], # 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[bold slowness], %i[muted spacer], %i[default location], ],
-          [], # New Line
-        ]
-      }
-
       attr_reader :stream
 
       def initialize(stream = $stdout)
@@ -112,159 +30,50 @@ module Minitest
       end
       alias newline puts
 
-      def marker(value)
-        case value
-        when 'E' then text(:error, value)
-        when 'B' then text(:failure, value)
-        when 'F' then text(:failure, value)
-        when 'S' then text(:skipped, value)
-        when 'T' then text(:slow, value)
-        else          text(:success, value)
-        end
-      end
-
       def issue_details(issue)
-        formatter = FORMATTERS[issue.type]
-
-        formatter.each do |lines|
-          lines.each do |tokens|
-            style, content_method = *tokens
-
-            if issue.respond_to?(content_method)
-              # If it's an available method on issue, use that to get the content
-              content = issue.send(content_method)
-              text(style, content)
-            else
-              # Otherwise, fall back to output and pass issue to *it*
-              send(content_method, issue)
-            end
-          end
-          newline
-        end
+        print_tokens Minitest::Heat::Output::Issue.new(issue).tokens
       end
 
-      def heat_map(map)
-        # text(:default, "🔥 Hot Spots 🔥\n")
-        map.files.each do |file|
-          file = file[0]
-          values = map.hits[file]
-
-          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(:failure, 'F' * values[:failure].size) if values[:failure]&.any?
-          text(:skipped, 'S' * values[:skipped].size) if values[:skipped]&.any?
-          text(:slow, 'S' * values[:skipped].size) if values[:skipped]&.any?
-
-          text(:muted, ' ')
-
-          text(:muted, "#{path.delete_prefix('/')}")
-          text(:default, "#{filename}")
-
-          text(:muted, ':')
-
-          all_line_numbers = values.fetch(:error, []) + values.fetch(:failure, [])
-          all_line_numbers += values.fetch(:skipped, [])
-
-          line_numbers = all_line_numbers.compact.uniq.sort
-          line_numbers.each { |line_number| text(:subtle, "#{line_number} ") }
-          newline
-        end
-        newline
+      def marker(issue_type)
+        print_token Minitest::Heat::Output::Marker.new(issue_type).token
       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(:subtle, "#{results.tests_per_second} tests/s and #{results.assertions_per_second} assertions/s ")
-
-        newline
-        text(:muted, pluralize(results.test_count, 'Test') + ' & ')
-        text(:muted, pluralize(results.assertion_count, 'Assertion'))
-        text(:muted, " in #{results.total_time.round(2)}s")
+        print_tokens ::Minitest::Heat::Output::Results.new(results).tokens
+      end
 
+      def heat_map(map)
         newline
-        newline
+        print_tokens ::Minitest::Heat::Output::Map.new(map).tokens
       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)
-
-          text(:muted, "  #{line.path.delete_prefix("#{Dir.pwd}/")}/")
-          text(:subtle, "#{line.file}:#{line.number}")
-          text(:source, " `#{source.line.strip}`")
-
-          newline
-        end
-      end
-
-      def source_summary(issue)
-        filename = issue.location.source_file
-        line_number = issue.location.source_failure_line
-
-        source = Minitest::Heat::Source.new(filename, line_number: line_number, max_line_count: 3)
-        show_source(source, highlight_line: true, indentation: 2)
-      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
-                                       [:subtle, :subtle]
-                                     end
-          text(number_style, "#{' ' * indentation}#{line_number.to_s.rjust(max_line_number_length)} ")
-          text(line_style, line)
-          puts
-        end
-      end
-
       def style_enabled?
         stream.tty?
       end
 
-      def pluralize(count, singular)
-        singular_style = "#{count} #{singular}"
+      def text(style, content)
+        token = Token.new(style, content)
+        print token.to_s(token_format)
+      end
 
-        # Given the narrow scope, pluralization can be relatively naive here
-        count > 1 ? "#{singular_style}s" : singular_style
+      def token_format
+        style_enabled? ? :styled : :unstyled
       end
 
-      def text(style, content)
-        formatted_content = style_enabled? ? Token.new(style, content).to_s : content
+      def print_token(token)
+        print Token.new(*token).to_s(token_format)
+      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