minitest-heat 0.0.1

data/lib/minitest/heat/location.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Location
+      attr_reader :test_location, :backtrace
+
+      def initialize(test_location, backtrace = [])
+        @test_location = test_location
+        @backtrace = Backtrace.new(backtrace)
+      end
+
+      def to_s
+        "#{source_file}:#{source_failure_line}"
+      end
+
+      def failure_in_test?
+        !test_file.nil? && test_file == source_file
+      end
+
+      def failure_in_source?
+        !failure_in_test?
+      end
+
+      def test_file
+        reduced_path(test_location[0])
+      end
+
+      def test_definition_line
+        test_location[1].to_s
+      end
+
+      def test_failure_line
+        @backtrace.final_test_location.number
+      end
+
+      def source_file
+        return test_file if backtrace.empty?
+
+        source_line = backtrace.final_project_location
+
+        reduced_path("#{source_line.path}/#{source_line.file}")
+      end
+
+      def source_failure_line
+        return test_definition_line if backtrace.empty?
+
+        backtrace.final_project_location.number
+      end
+
+      def project_directory_name
+        Dir.pwd.split('/').last
+      end
+
+      private
+
+      def reduced_path(path)
+        "/#{path.split("/#{project_directory_name}/").last}"
+      end
+    end
+  end
+end
+
+

data/lib/minitest/heat/map.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Map
+      attr_reader :hits
+
+      # So we can sort hot spots by liklihood of being the most important spot to check out before
+      #   trying to fix something. These are ranked based on the possibility they represent ripple
+      #   effects where fixing one problem could potentially fix multiple other failures.
+      #
+      #   For example, if there's an exception in the file, start there. Broken code can't run. If a
+      #   test is broken (i.e. raising an exception), that's a special sort of failure that would be
+      #   misleading. It doesn't represent a proper failure, but rather a test that doesn't work.
+      WEIGHTS = {
+        error: 3,   # exceptions from source code have the highest liklihood of a ripple effect
+        broken: 1,  # broken tests won't have ripple effects but can't help if they can't run
+        failure: 1, # failures are kind of the whole point, and they could have ripple effects
+        skipped: 0, # skips aren't failures, but they shouldn't go ignored
+        slow: 0     # slow tests aren't failures, but they shouldn't be ignored
+      }
+
+      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][type] ||= []
+        @hits[filename][type] << line_number
+      end
+
+      def files
+        hot_files
+          .sort_by { |filename, weight| weight }
+          .reverse
+          .take(5)
+      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
+      end
+    end
+  end
+end

data/lib/minitest/heat/output.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+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)
+        @stream = stream.tap do |str|
+          # If the IO channel supports flushing the output immediately, then ensure it's enabled
+          str.sync = str.respond_to?(:sync=)
+        end
+      end
+
+      def print(*args)
+        stream.print(*args)
+      end
+
+      def puts(*args)
+        stream.puts(*args)
+      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
+      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
+      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")
+
+        newline
+        newline
+      end
+
+      private
+
+      def test_name_summary(issue)
+        text(:default, "#{issue.test_class} > #{issue.test_name}")
+      end
+
+      def backtrace_summary(issue)
+        lines = issue.backtrace.project
+
+        line = lines.first
+        filename = "#{line.path.delete_prefix(Dir.pwd)}/#{line.file}"
+
+        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}"
+
+        # Given the narrow scope, pluralization can be relatively naive here
+        count > 1 ? "#{singular_style}s" : singular_style
+      end
+
+      def text(style, content)
+        formatted_content = style_enabled? ? Token.new(style, content).to_s : content
+
+        print formatted_content
+      end
+    end
+  end
+end

data/lib/minitest/heat/results.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Heat
+    class Results
+
+      attr_reader :test_count,
+                  :assertion_count,
+                  :success_count,
+                  :issues,
+                  :start_time,
+                  :stop_time
+
+      def initialize
+        @test_count = 0
+        @assertion_count = 0
+        @success_count = 0
+        @issues = {
+          error: [],
+          broken: [],
+          failure: [],
+          skipped: [],
+          slow: []
+        }
+        @start_time = nil
+        @stop_time = nil
+      end
+
+      def start_timer!
+        @start_time = Minitest.clock_time
+      end
+
+      def stop_timer!
+        @stop_time = Minitest.clock_time
+      end
+
+      def total_time
+        delta = @stop_time - @start_time
+
+        # Don't return 0
+        delta.zero? ? 0.1 : delta
+      end
+
+      def tests_per_second
+        (assertion_count / total_time).round(2)
+      end
+
+      def assertions_per_second
+        (assertion_count / total_time).round(2)
+      end
+
+      def issues?
+        errors? || failures? || skips?
+      end
+
+      def errors
+        issues.fetch(:error) { [] }
+      end
+
+      def brokens
+        issues.fetch(:broken) { [] }
+      end
+
+      def failures
+        issues.fetch(:failure) { [] }
+      end
+
+      def skips
+        issues.fetch(:skipped) { [] }
+      end
+
+      def slows
+        issues
+          .fetch(:slow) { [] }
+          .sort { |issue| issue.time }
+          .reverse
+          .take(3)
+      end
+
+      def errors?
+        errors.any?
+      end
+
+      def brokens?
+        brokens.any?
+      end
+
+      def failures?
+        failures.any?
+      end
+
+      def skips?
+        skips.any?
+      end
+
+      def count(result)
+        @test_count += 1
+        @assertion_count += result.assertions
+        @success_count += 1 if result.passed?
+      end
+
+      def record_issue(result)
+        issue = Heat::Issue.new(result)
+
+        @issues[issue.type] ||= []
+        @issues[issue.type] << issue
+
+        issue
+      end
+    end
+  end
+end