minitest-heat 0.0.1 → 0.0.5

data/lib/minitest/heat/output.rb

@@ -1,94 +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
-      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[error label], %i[muted spacer], %i[default test_name] ],
+          [ %i[italicized 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[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[failure test_class], %i[muted arrow], %i[failure test_name], %i[muted spacer], %i[muted class] ],
-          [ %i[default summary] ],
-          [ %i[subtle 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[skipped test_class], %i[muted arrow], %i[skipped test_name] ],
-          [ %i[default summary], %i[muted spacer], %i[default class] ],
+          [ %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
         ]
@@ -112,17 +59,22 @@ 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)
         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
 
+      # 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]
 
@@ -143,25 +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(:slow, 'S' * values[:skipped].size) if values[:skipped]&.any?
 
-          text(:muted, ' ')
+          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('/')}")
-          text(:default, "#{filename}")
+          text(:muted, "#{path.delete_prefix(Dir.pwd)}/")
+          text(:default, filename)
 
           text(:muted, ':')
 
@@ -169,102 +127,62 @@ module Minitest
           all_line_numbers += values.fetch(:skipped, [])
 
           line_numbers = all_line_numbers.compact.uniq.sort
-          line_numbers.each { |line_number| text(:subtle, "#{line_number} ") }
+          line_numbers.each { |line_number| text(:muted, "#{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 ")
+      # 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)
-        lines = issue.backtrace.project
-
-        line = lines.first
-        filename = "#{line.path.delete_prefix(Dir.pwd)}/#{line.file}"
+        location = issue.location
 
-        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
+        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
-                                       [:subtle, :subtle]
-                                     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

@@ -49,8 +49,8 @@ module Minitest
         (assertion_count / total_time).round(2)
       end
 
-      def issues?
-        errors? || failures? || skips?
+      def problems?
+        errors? || brokens? || failures? || skips?
       end
 
       def errors
@@ -93,19 +93,17 @@ module Minitest
         skips.any?
       end
 
-      def count(result)
-        @test_count += 1
-        @assertion_count += result.assertions
-        @success_count += 1 if result.passed?
+      def slows?
+        slows.any?
       end
 
-      def record_issue(result)
-        issue = Heat::Issue.new(result)
+      def record(issue)
+        @test_count += 1
+        @assertion_count += issue.result.assertions
+        @success_count += 1 if issue.result.passed?
 
         @issues[issue.type] ||= []
         @issues[issue.type] << issue
-
-        issue
       end
     end
   end

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.1"
+    VERSION = "0.0.5"
   end
 end

data/lib/minitest/heat_reporter.rb

@@ -59,14 +59,12 @@ module Minitest
     # Minitest::Result source:
     #   https://github.com/seattlerb/minitest/blob/f4f57afaeb3a11bd0b86ab0757704cb78db96cf4/lib/minitest.rb#L504
     def record(result)
-      @results.count(result)
-      if !result.passed? || result.time > ::Minitest::Heat::Issue::SLOW_THRESHOLD
-        issue = @results.record_issue(result)
-        @map.add(*issue.to_hit)
-        output.marker(issue.marker)
-      else
-        output.marker(result.result_code)
-      end
+      issue = Heat::Issue.new(result)
+
+      @results.record(issue)
+      @map.add(*issue.to_hit) if issue.hit?
+
+      output.marker(issue.marker)
     end
 
     # Outputs the summary of the run.
@@ -80,14 +78,19 @@ module Minitest
       #   pressing issues are displayed at the bottom of the report in order to reduce scrolling.
       #   This way, as you fix issues, the list gets shorter, and eventually the least critical
       #   issues will be displayed without scrolling once more problematic issues are resolved.
-      results.slows.each { |issue| output.issue_details(issue) }
-      results.skips.each { |issue| output.issue_details(issue) }
+      if results.failures.empty? && results.brokens.empty? && results.errors.empty? && results.skips.empty?
+        results.slows.each { |issue| output.issue_details(issue) }
+      end
+
+      if results.failures.empty? && results.brokens.empty? && results.errors.empty?
+        results.skips.each { |issue| output.issue_details(issue) }
+      end
+
       results.failures.each { |issue| output.issue_details(issue) }
       results.brokens.each { |issue| output.issue_details(issue) }
       results.errors.each { |issue| output.issue_details(issue) }
 
       output.compact_summary(results)
-
       output.heat_map(map)
     end
 

data/minitest-heat.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency 'minitest'
 
+  spec.add_development_dependency 'dead_end'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'simplecov'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-heat
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.5
 platform: ruby
 authors:
 - Garrett Dimon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-26 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dead_end
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -76,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