minitest-bender 0.0.3 → 1.0.0

data/lib/minitest-bender/results/expectation.rb

@@ -1,26 +1,28 @@
 module MinitestBender
   module Results
     class Expectation < Base
+      attr_reader :name
+
       def initialize(minitest_result, number, name)
         super(minitest_result)
         @number = number
         @name = name
       end
 
-      def line_to_report
-        "#{formatted_label}#{formatted_time} #{formatted_number} #{name} #{formatted_message}"
+      def formatted_number(_sorted_siblings = nil)
+        " #{Colorizer.colorize(number, :number)} "
       end
 
-      private
+      def number_sort_key
+        @number_sort_key ||= number.to_i
+      end
 
-      attr_reader :number, :name
+      private
 
-      def formatted_number
-        "#{Colorin.brown_400(number)} "
-      end
+      attr_reader :number
 
       def name_for_rerun_command
-        "/#{name.gsub(' ', '\\ ')}/"
+        "/#{name.gsub(/[^a-zA-Z0-9_\-{}#@]/, '.')}$/"
       end
     end
   end

data/lib/minitest-bender/results/test.rb

@@ -6,17 +6,22 @@ module MinitestBender
         @raw_name = raw_name
       end
 
-      def context
-        super.gsub(/^Test|Test$/, '')
-      end
+      def formatted_number(sorted_siblings = nil)
+        return '' if sorted_siblings.nil?
 
-      def line_to_report
-        "#{formatted_label}#{formatted_time} #{name} #{formatted_message}"
-      end
+        number = sorted_siblings.find_index do |result|
+          result.source_line_number > source_line_number
+        end || sorted_siblings.size
+        # this is never 0 because sorted_siblings includes self
 
-      private
+        padded_number = number.to_s.rjust(4, '0')
 
-      attr_reader :raw_name
+        " #{Colorizer.colorize(padded_number, :number)} "
+      end
+
+      def number_sort_key
+        source_line_number
+      end
 
       def name
         @name ||= begin
@@ -28,6 +33,14 @@ module MinitestBender
         end
       end
 
+      private
+
+      attr_reader :raw_name
+
+      def adjusted_class_name
+        class_name.gsub(/^Test|Test$/, '')
+      end
+
       def name_for_rerun_command
         minitest_result.name
       end

data/lib/minitest-bender/sections/activity.rb

@@ -0,0 +1,95 @@
+module MinitestBender
+  module Sections
+    class Activity
+      TIME_UNITS = %w[day hour minute second].freeze
+
+      def initialize(io, started_at, results)
+        @io = io
+        @started_at = started_at
+        @results = results
+      end
+
+      def print
+        io.puts "  #{formatted_total_tests} with #{formatted_total_assertions} #{auxiliary_verb} run in #{formatted_total_time} (#{formatted_tests_rate}, #{formatted_assertions_rate})"
+        io.puts
+      end
+
+      private
+
+      attr_reader :io, :started_at, :results
+
+      def formatted_total_tests
+        Colorizer.colorize(total_tests, :tests)
+      end
+
+      def formatted_total_assertions
+        Colorizer.colorize(total_assertions, :assertions)
+      end
+
+      def auxiliary_verb
+        test_count == 1 ? 'was' : 'were'
+      end
+
+      def formatted_total_time
+        Colorizer.colorize(total_time_string, :time)
+      end
+
+      def formatted_tests_rate
+        Colorizer.colorize("#{tests_rate} tests/s", :time)
+      end
+
+      def formatted_assertions_rate
+        Colorizer.colorize("#{assertions_rate} assertions/s", :time)
+      end
+
+      def tests_rate
+        (test_count / total_time).round(4)
+      end
+
+      def assertions_rate
+        (assertion_count / total_time).round(4)
+      end
+
+      def total_tests
+        "#{test_count} test#{test_count == 1 ? '' : 's'}"
+      end
+
+      def total_assertions
+        "#{assertion_count} assertion#{assertion_count == 1 ? '' : 's'}"
+      end
+
+      def test_count
+        results.size
+      end
+
+      def assertion_count
+        @assertion_count ||= results.reduce(0) { |acum, result| acum + result.assertions }
+      end
+
+      def total_time_string
+        minutes, seconds = total_time.divmod(60)
+        hours, minutes = minutes.divmod(60)
+        days, hours = hours.divmod(24)
+
+        values = [days, hours, minutes]
+        seconds_decimals = values.all?(&:zero?) ? 3 : 0
+        values.push(seconds.round(seconds_decimals))
+
+        values_with_units = values.map.with_index do |value, index|
+          unit = time_units[index]
+          value > 0 ? "#{value} #{unit}#{value.to_s == '1' ? '' : 's'}" : ''
+        end
+
+        Utils.english_join(values_with_units)
+      end
+
+      def total_time
+        @total_time ||= Time.now - started_at
+      end
+
+      def time_units
+        TIME_UNITS
+      end
+    end
+  end
+end

data/lib/minitest-bender/sections/issues.rb

@@ -0,0 +1,22 @@
+module MinitestBender
+  module Sections
+    class Issues
+      def initialize(io)
+        @io = io
+      end
+
+      def print
+        symbols = states.map { |state| state.print_details(io) }
+        io.puts unless symbols.all? { |symbol| symbol == :no_details }
+      end
+
+      private
+
+      attr_reader :io
+
+      def states
+        MinitestBender.states.values
+      end
+    end
+  end
+end

data/lib/minitest-bender/sections/sorted_overview.rb

@@ -0,0 +1,115 @@
+module MinitestBender
+  module Sections
+    class SortedOverview
+      def initialize(io, results_by_context)
+        @io = io
+        @contexts_with_results = sorted_pairs(results_by_context)
+      end
+
+      def print
+        return if trivial?
+
+        io.puts(formatted_label)
+        io.puts
+        previous_context_path = []
+        contexts_with_results.each do |context, results|
+          io.puts
+          print_context(context, previous_context_path)
+          previous_context_path = context.path
+          words = []
+          results.sort_by(&sort_key).each do |result|
+            words = print_result(result, words, results)
+          end
+        end
+        io.puts
+        print_divider
+      end
+
+      private
+
+      attr_reader :io, :contexts_with_results
+
+      def sorted_pairs(results_by_context)
+        results_by_context.map do |context, results|
+          [context, results.sort_by(&:source_location)]
+        end.sort
+      end
+
+      def trivial?
+        results.size < 2
+      end
+
+      def results
+        contexts_with_results.map(&:last).flatten
+      end
+
+      def formatted_label
+        "  #{Colorizer.colorize('SORTED OVERVIEW', :normal, :bold, :underline)}"
+      end
+
+      def print_context(result_context, previous_context_path)
+        formatted_context = formatted_old_and_new(
+          previous_context_path,
+          result_context.path,
+          result_context.separator
+        )
+
+        io.puts(result_context.prefix + formatted_context)
+      end
+
+      def sort_key
+        @sort_key ||= "#{Minitest::Bender.configuration.overview_sort_key}_sort_key".to_sym
+      end
+
+      def print_result(result, previous_words, sorted_siblings)
+        formatted_number = result.formatted_number(sorted_siblings)
+
+        prefix = "    #{result.formatted_label_and_time}#{formatted_number}"
+        words = result.name.split(' ')
+
+        formatted_words = formatted_old_and_new(previous_words, words, ' ')
+
+        formatted_message = result.formatted_message
+        if formatted_message.empty?
+          details = ''
+        else
+          details = "  #{formatted_message.split("\n").first}"
+        end
+
+        io.puts("#{prefix} #{formatted_words}#{details}")
+        words
+      end
+
+      def formatted_old_and_new(previous, current, separator)
+        old_part, new_part = old_and_new(previous, current)
+
+        old_part_string = old_part.join(separator)
+        old_part_string << separator unless old_part_string.empty?
+        new_part_string = new_part.join(separator)
+
+        formatted_old = Colorizer.colorize(old_part_string, :normal)
+        formatted_new = Colorizer.colorize(new_part_string, :normal, :bold)
+
+        "#{formatted_old}#{formatted_new}"
+      end
+
+      def old_and_new(previous, current)
+        cut_index = first_difference_index(previous, current) || previous.size
+        cut_at(current, cut_index)
+      end
+
+      def first_difference_index(xs, ys)
+        xs.find_index.with_index { |x, i| x != ys[i] }
+      end
+
+      def cut_at(xs, i)
+        [xs.take(i), xs.drop(i)]
+      end
+
+      def print_divider
+        io.puts(Colorizer.colorize("  #{'_' * 23}", :normal, :bold))
+        io.puts
+      end
+    end
+  end
+end

data/lib/minitest-bender/sections/suite_status.rb

@@ -0,0 +1,72 @@
+module MinitestBender
+  module Sections
+    class SuiteStatus
+      def initialize(io, options, results, total_tests_count)
+        @io = io
+        @options = options
+        @results = results
+        @total_tests_count = total_tests_count
+      end
+
+      def print
+        final_divider_color = all_passed_color
+
+        if all_tests_passed?
+          message = Colorizer.colorize('  ALL TESTS PASS!  (^_^)/', all_passed_color)
+        else
+          messages = MinitestBender.states.values.map do |state|
+            summary_message = state.summary_message
+            final_divider_color = state.color unless summary_message.empty?
+            summary_message
+          end
+
+          message = "  #{Utils.english_join(messages)}"
+        end
+        io.puts(message)
+
+        print_divider(final_divider_color)
+      end
+
+      private
+
+      attr_reader :io, :options, :results, :total_tests_count
+
+      def all_passed_color
+        :pass
+      end
+
+      def all_tests_passed?
+        all_tests_were_run? && all_run_tests_passed?
+      end
+
+      def all_tests_were_run?
+        !restricted_run? && !interrupted?
+      end
+
+      def restricted_run?
+        (options.key?(:filter) && options[:filter] != '/./') || options.key?(:exclude)
+      end
+
+      def interrupted?
+        test_count < total_tests_count
+      end
+
+      def all_run_tests_passed?
+        test_count == passed_count
+      end
+
+      def test_count
+        results.size
+      end
+
+      def passed_count
+        @passed_count ||= results.count(&:passed?)
+      end
+
+      def print_divider(color)
+        io.puts(Colorizer.colorize("  #{'_' * 23}", color, :bold))
+        io.puts
+      end
+    end
+  end
+end

data/lib/minitest-bender/sections/time_ranking.rb

@@ -0,0 +1,49 @@
+module MinitestBender
+  module Sections
+    class TimeRanking
+      def initialize(io, size, results)
+        @io = io
+        @size = size
+        @results = results
+      end
+
+      def print
+        return if trivial?
+
+        io.puts(formatted_label)
+        io.puts
+        sorted_results_to_show.each_with_index do |result, i|
+          number = "#{i + 1})".ljust(4)
+          io.puts "    #{number}#{result.formatted_time} #{result.formatted_name_with_context}"
+        end
+        print_divider
+        io.puts
+      end
+
+      private
+
+      attr_reader :io, :size, :results
+
+      def trivial?
+        size < 1 || results.size < 2
+      end
+
+      def formatted_label
+        "  #{Colorizer.colorize('TIME RANKING', :time, :bold, :underline)}"
+      end
+
+      def sorted_results_to_show
+        sorted_results.take(size)
+      end
+
+      def sorted_results
+        results.sort_by { |r| -r.time }
+      end
+
+      def print_divider
+        io.puts(Colorizer.colorize("  #{'_' * 23}", :normal, :bold))
+        io.puts
+      end
+    end
+  end
+end

data/lib/minitest-bender/states/base.rb

@@ -1,33 +1,81 @@
 module MinitestBender
   module States
     class Base
+      attr_reader :results
+
+      def initialize
+        @results = []
+      end
+
+      def add_result(result)
+        results.push(result)
+      end
+
       def formatted_label
         @formatted_label ||= colored(label.ljust(7))
       end
 
       def formatted_group_label
-        @formatted_group_label ||= "  #{colored(group_label).bold.underline}"
+        @formatted_group_label ||= "  #{colored(group_label, :bold, :underline)}"
+      end
+
+      def colored_icon
+        colored(icon)
+      end
+
+      def colored_icon_with_count(padding_right = 0)
+        with_colored_icon(results.size, padding_right)
       end
 
-      def print_details(io, results)
-        filtered_results = only_with_this_state(results)
-        return :no_details if filtered_results.empty?
+      def colored_icon_with_context_count(result_context, padding_right = 0)
+        context_count = results.count { |r| r.context == result_context }
+        with_colored_icon(context_count, padding_right)
+      end
+
+      def print_details(io)
+        return :no_details if results.empty?
+
+        sorted_results = results.sort_by(&:source_location)
 
         io.puts formatted_group_label
         io.puts
-        filtered_results.each_with_index do |result, i|
-          number = "#{i + 1})".ljust(4)
-          padding = ' ' * (number.size + 4)
-          io.puts(result.details_header(number))
-          do_print_details(io, result, padding)
-          io.puts
-          io.puts(result.rerun_line(padding))
-          io.puts if i < filtered_results.size - 1
+        sorted_results.each_with_index do |result, i|
+          detail_lines(result).each { |line| io.puts line }
+          io.puts if i < results.size - 1
         end
         io.puts
         :printed_details
       end
 
+      def detail_lines(result)
+        number = "#{result.execution_order})".ljust(4)
+        padding = ' ' * (number.size + 4)
+        time = "(#{result.time_with_unit_and_padding_right.strip})"
+        lines = []
+        lines << "    #{number}#{result.formatted_name_with_context} #{Colorizer.colorize(time, :time)}"
+
+        lines += inner_detail_lines(result, padding)
+
+        lines << ''
+        lines << result.rerun_line(padding)
+        lines
+      end
+
+      def detail_lines_without_header(result)
+        number = "#{result.execution_order})".ljust(4)
+        padding = ' ' * (number.size + 2)
+        lines = []
+
+        lines += inner_detail_lines(result, padding).tap do |ls|
+          ls[0] = "  #{number}#{ls[0].strip}" unless ls.empty?
+        end
+
+        lines << ''
+        lines << result.rerun_line(padding)
+        lines << ''
+        lines
+      end
+
       def color
         self.class::COLOR
       end
@@ -46,19 +94,28 @@ module MinitestBender
         self.class::GROUP_LABEL
       end
 
-      def colored(string)
-        Colorin.public_send(color, string)
+      def icon
+        self.class::ICON
+      end
+
+      def colored(string, *args)
+        Colorizer.colorize(string, color, *args)
       end
 
-      def only_with_this_state(results)
-        results.select { |result| result.state?(self) }
+      def with_colored_icon(message, padding_right)
+        colored("#{icon}#{message}".ljust(padding_right, ' '))
       end
 
-      def do_print_details(io, result, padding)
+      def inner_detail_lines(result, padding)
+        lines = []
         result.failures[0].message.split("\n").each do |line|
-          io.puts "#{padding}#{colored(line)}"
+          line.split("\\n").each do |actual_line|
+            adjusted_line = Utils.with_home_shorthand(actual_line)
+            lines << "#{padding}#{colored(adjusted_line)}"
+          end
         end
-        io.puts "#{padding}#{Colorin.brown_400(location(result))}"
+        lines << "#{padding}#{Colorizer.colorize(location(result), :backtrace)}:"
+        lines
       end
 
       def location(result)