ruptr 0.1.3

data/lib/ruptr/stringified.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'pp'
+
+module Ruptr
+  # Helper to get a string representation of an arbitrary object and write it to an IO stream while
+  # attempting to deal with weird/buggy objects as well as possible.
+  class Stringified
+    def self.stringification_methods = %i[pretty_inspect inspect to_s]
+
+    def self.from(value) = value.is_a?(self) ? value : new(value)
+
+    def initialize(value)
+      # String.new is used to get an immutable snapshot of the strings and also to make sure that
+      # they are not derived classes or have instance variables that could make them unserializable.
+      @original_class_name = String.new(value.class.to_s)
+      if (@originally_a_string = value.class <= String)
+        @stringified = String.new(value)
+      else
+        if (name = self.class.stringification_methods.find { |name| value.respond_to?(name) })
+          # NOTE: String.new may call #to_s on the method's return value if needed.
+          @stringified = String.new(value.public_send(name))
+          @stringification_method = name
+        end
+      end
+    end
+
+    attr_reader :original_class_name,
+                :stringified,
+                :stringification_method
+
+    def originally_a_string? = @originally_a_string
+    def stringified? = !@stringified.nil?
+
+    def compatible_with_io?(io)
+      return nil unless stringified?
+      @stringified.valid_encoding? &&
+        Encoding.compatible?(@stringified, io.external_encoding) == io.external_encoding
+    end
+
+    private def unstringifiable_fallback = "#<#{self.class}: unstringifiable object of class #{@original_class_name}>"
+
+    def string_for_io(io)
+      case
+      when !stringified? then unstringifiable_fallback
+      when compatible_with_io?(io) then @stringified
+      else @stringified.b.inspect
+      end
+    end
+
+    def write_to_io(io) = io.write(string_for_io(io))
+
+    def string = stringified? ? @stringified : unstringifiable_fallback
+    alias to_s string
+    alias to_str string
+  end
+end

data/lib/ruptr/suite.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Ruptr
+  class TestElement
+    DEFAULT_TAGS = {}.freeze
+
+    def initialize(label = nil, identifier: label, tags: DEFAULT_TAGS, &block)
+      @parent = nil
+      @label = label
+      @identifier = identifier
+      @tags = tags
+      @block = block
+    end
+
+    attr_accessor :label, :identifier, :tags, :block
+
+    attr_reader :parent
+
+    def orphan? = @parent.nil?
+
+    def reparent!(new_parent)
+      fail "already has a parent" if new_parent && @parent
+      @parent = new_parent
+      @description = nil
+    end
+
+    def orphanize! = reparent!(nil)
+
+    def description
+      return label.nil? ? '' : label if orphan?
+      @description ||= if label.nil?
+                         parent.description
+                       elsif parent.description.empty?
+                         label
+                       else
+                         "#{parent.description} #{label}"
+                       end
+    end
+
+    def each_parent_and_self(&)
+      return to_enum __method__ unless block_given?
+      parent.each_parent_and_self(&) unless orphan?
+      yield self
+    end
+
+    def path_labels = each_parent_and_self.map(&:label)
+    def path_identifiers = each_parent_and_self.map(&:identifier)
+
+    def test_case? = false
+    def test_group? = false
+
+    def block? = !@block.nil?
+
+    def initialize_dup(_)
+      super
+      orphanize!
+    end
+
+    def to_s = "#<#{self.class}: #{description.inspect}>"
+  end
+
+  class TestCase < TestElement
+    def test_case? = true
+
+    def run_context(context) = @block.call(context)
+  end
+
+  class TestGroup < TestElement
+    def initialize(...)
+      super
+      @test_cases = []
+      @test_subgroups = []
+    end
+
+    def test_group? = true
+
+    def wrap_context(context, &) = @block.call(context, &)
+
+    def each_test_case(&) = @test_cases.each(&)
+    def each_test_subgroup(&) = @test_subgroups.each(&)
+
+    def each_test_element(&)
+      return to_enum __method__ unless block_given?
+      each_test_case(&)
+      each_test_subgroup(&)
+    end
+
+    def each_test_element_recursive(&)
+      return to_enum __method__ unless block_given?
+      yield self
+      each_test_case(&)
+      each_test_subgroup { |tg| tg.each_test_element_recursive(&) }
+    end
+
+    def each_test_case_recursive(&)
+      return to_enum __method__ unless block_given?
+      each_test_case(&)
+      each_test_subgroup { |tg| tg.each_test_case_recursive(&) }
+    end
+
+    def each_test_group_recursive(&)
+      return to_enum __method__ unless block_given?
+      yield self
+      each_test_subgroup do |tg|
+        yield tg
+        tg.each_test_subgroup_recursive(&)
+      end
+    end
+
+    def each_test_subgroup_recursive(&)
+      return to_enum __method__ unless block_given?
+      each_test_subgroup do |tg|
+        yield tg
+        tg.each_test_subgroup_recursive(&)
+      end
+    end
+
+    def count_test_elements(&) = each_test_element_recursive.count(&)
+    def count_test_cases(&) = each_test_case_recursive.count(&)
+    def count_test_groups(&) = each_test_group_recursive.count(&)
+    def count_test_subgroups(&) = each_test_subgroup_recursive.count(&)
+
+    def empty? = @test_cases.empty? && @test_subgroups.empty?
+
+    def clear_test_cases
+      @test_cases.each(&:orphanize!)
+      @test_cases.clear
+    end
+
+    def clear_test_subgroups
+      @test_subgroups.each(&:orphanize!)
+      @test_subgroups.clear
+    end
+
+    def add_test_case(tc)
+      tc.reparent!(self)
+      @test_cases << tc
+    end
+
+    def add_test_subgroup(tg)
+      tg.reparent!(self)
+      @test_subgroups << tg
+    end
+
+    def add_test_element(te)
+      case
+      when te.test_case? then add_test_case(te)
+      when te.test_group? then add_test_subgroup(te)
+      else raise ArgumentError
+      end
+    end
+
+    def filter_recursive!(&)
+      @test_cases.filter!(&)
+      @test_subgroups.filter! do |tg|
+        if yield tg
+          tg.filter_recursive!(&)
+          true
+        end
+      end
+    end
+
+    def filter_recursive(&)
+      dup.tap { |tg| tg.filter_recursive!(&) }
+    end
+
+    def filter_test_cases_recursive(&)
+      filter_recursive { |te| !te.test_case? || yield(te) }
+    end
+
+    def initialize_dup(_)
+      super
+      @test_cases = @test_cases.map { |tc| tc.dup.tap { |tc| tc.reparent!(self) } }
+      @test_subgroups = @test_subgroups.map { |tc| tc.dup.tap { |tc| tc.reparent!(self) } }
+    end
+
+    def freeze
+      @test_cases.each(&:freeze)
+      @test_subgroups.each(&:freeze)
+      @test_cases.freeze
+      @test_subgroups.freeze
+      super
+    end
+  end
+
+  class TestSuite < TestGroup
+  end
+end

data/lib/ruptr/surrogate_exception.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ruptr
+  # Exception that copy some of the information of another original exception in a way that
+  # (hopefully) can be safely marshalled.
+  class SurrogateException < Exception
+    def self.detailed_message_supported? = Exception.method_defined?(:detailed_message)
+
+    def self.from_1(original_exception)
+      new(original_exception.message,
+          **if detailed_message_supported?
+              {
+                detailed_message: original_exception.detailed_message(highlight: false),
+                highlighted_detailed_message: original_exception.detailed_message(highlight: true),
+              }
+            else
+              {}
+            end,
+          original_class_name: original_exception.class.name,
+          backtrace: original_exception.backtrace)
+    end
+
+    def self.from(original_exception)
+      return from_1(original_exception) unless original_exception.cause
+      # Recreate the cause exception chain by raising the surrogate exceptions.  Simply redefining
+      # the #cause method does not work in CRuby (apparently the cause is stored in a special
+      # instance variable that is then accessed directly).
+      rec = lambda do |ex|
+        if ex.cause
+          if ex.cause.cause
+            begin
+              rec.call(ex.cause)
+            rescue self
+              raise from_1(ex)
+            end
+          else
+            raise from_1(ex), cause: from_1(ex.cause)
+          end
+        else
+          raise from_1(ex), cause: nil # don't use implicit $!, if any
+        end
+      end
+      begin
+        rec.call(original_exception)
+      rescue self
+        $!
+      end
+    end
+
+    private def safe_string(v) = v.nil? ? v : String.new(v)
+
+    def initialize(message = nil,
+                   detailed_message: nil, highlighted_detailed_message: nil,
+                   original_class_name: nil,
+                   backtrace: nil)
+      super(safe_string(message))
+      @detailed_message = safe_string(detailed_message)
+      @highlighted_detailed_message = safe_string(highlighted_detailed_message)
+      set_backtrace(backtrace)
+      @original_class_name = safe_string(original_class_name)
+    end
+
+    attr_reader :original_class_name
+
+    if detailed_message_supported?
+      def detailed_message(highlight: false, **_)
+        (highlight ? @highlighted_detailed_message || @detailed_message : @detailed_message) || super
+      end
+    end
+  end
+end

data/lib/ruptr/tabular.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'formatter'
+require_relative 'result'
+
+module Ruptr
+  class Formatter::Tabular < Formatter
+    self.formatter_name = :tabular
+
+    private
+
+    def initialize(output, **opts)
+      super(**opts)
+      @output = output
+    end
+
+    def finish_element(te, tr)
+      @output.printf("%-7s %12.6f %s\n", tr.status, tr.processor_time || Float::NAN, te.description)
+    end
+  end
+end

data/lib/ruptr/tap.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'sink'
+require_relative 'formatter'
+require_relative 'exceptions'
+
+module Ruptr
+  class Formatter::TAP < Formatter
+    self.formatter_name = :tap
+
+    include Sink
+
+    def initialize(output, **opts)
+      super(**opts)
+      @output = output
+    end
+
+    def begin_plan(fields)
+      @total_tests = 0
+      if (n = fields[:planned_test_case_count])
+        @output << "1..#{n}\n"
+        @emitted_plan = true
+      else
+        @emitted_plan = false
+      end
+    end
+
+    def finish_plan(_fields)
+      return if @emitted_plan
+      @output << "1..#{@total_tests}\n"
+    end
+
+    private def escape(s) = s.gsub(/[\\#]/) { |m| "\\#{m}" }
+
+    def finish_element(te, tr)
+      pending = tr.skipped? && tr.exception.is_a?(PendingSkippedMixin)
+      @output << (tr.passed? || (tr.skipped? && !pending) ? "ok" : "not ok")
+      @output << ' ' << @total_tests.succ.to_s
+      @output << ' - ' << escape(te.description) if te.description
+      if tr.skipped?
+        @output << ' # ' << (pending ? "TODO" : "SKIP")
+        @output << ' ' << escape(tr.exception.message) if tr.exception&.message
+      end
+      @output << "\n"
+      if tr.failed? && tr.exception
+        tr.exception.full_message(highlight: false).each_line { |s| @output << '# ' << s }
+      end
+      @total_tests += 1
+    end
+  end
+end

data/lib/ruptr/testunit/override.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative '../testunit'
+Ruptr::Compat::TestUnit.new.prepare_autorun!

data/lib/ruptr/testunit.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative 'suite'
+require_relative 'compat'
+require_relative 'autorun'
+require_relative 'adapters/assertions'
+
+module Ruptr
+  class Compat
+    class TestUnit < self
+      def default_project_load_paths = %w[test]
+
+      def default_project_test_globs = %w[test/**/*[-_]test.rb test/**/test[-_]*.rb]
+
+      def global_install!
+        m = if Object.const_defined?(:Test)
+              Object.const_get(:Test)
+            else
+              Object.const_set(:Test, Module.new)
+            end
+        if m.const_defined?(:Unit)
+          return if m.const_get(:Unit) == @adapter_module
+          fail "test/unit already loaded!"
+        end
+        ::Test.const_set(:Unit, adapter_module)
+        this = self
+        m = Module.new do
+          define_method(:require) do |name|
+            name = name.to_path unless name.is_a?(String)
+            case name
+            when 'test/unit'
+              return
+            when 'test/unit/autorun'
+              this.schedule_autorun!
+              return
+            when 'core_assertions'
+              # Test::Unit::CoreAssertions#assert_separately spawns an interpreter with gems
+              # disabled and include path arguments based on the current $LOAD_PATH.
+              Gem.try_activate('test/unit')
+            else
+              fail "#{self.class.name}: unknown test/unit library: #{name}" if name.start_with?('test/unit/')
+            end
+            super(name)
+          end
+        end
+        Kernel.prepend(m)
+      end
+
+      module DefBlockHelpers
+        def def_module(name, &) = const_set(name, Module.new(&))
+        def def_class(name, &) = const_set(name, Class.new(&))
+      end
+
+      def adapter_module
+        @adapter_module ||= Module.new do
+          extend(DefBlockHelpers)
+
+          const_set :PendedError, Assertions::SkippedException
+          const_set :AssertionFailedError, Assertions::AssertionError
+
+          def_module(:Util) do
+            extend(DefBlockHelpers)
+            def_module(:Output) do
+              def capture_output(&) = Assertions.capture_io(&)
+            end
+          end
+
+          assertions_module = def_module(:Assertions) do
+            include(Adapters::RuptrAssertions)
+          end
+
+          def_class(:TestCase) do
+            include(TestInstance)
+            include(assertions_module)
+
+            attr_accessor :method_name
+
+            def setup = nil
+            def teardown = nil
+          end
+        end
+      end
+
+      private def make_run_block(klass, method_name)
+        lambda do |context|
+          inst = klass.new
+          inst.method_name = method_name
+          inst.ruptr_initialize_test_instance(context)
+          inst.ruptr_wrap_test_instance do
+            inst.setup
+            inst.public_send(method_name)
+          ensure
+            inst.teardown
+          end
+        end
+      end
+
+      def adapted_test_group
+        traverse = lambda do |klass|
+          root = klass.equal?(adapter_module::TestCase)
+          TestGroup.new(root ? "[TestUnit]" : klass.name,
+                        identifier: root ? :testunit : klass.name).tap do |tg|
+            klass.public_instance_methods(true)
+                 .filter { |sym| sym.start_with?('test_') }.each do |test_method_name|
+              tc = TestCase.new(test_method_name.to_s, &make_run_block(klass, test_method_name))
+              tg.add_test_case(tc)
+            end
+            klass.subclasses.each do |subklass|
+              tg.add_test_subgroup(traverse.call(subklass))
+            end
+          end
+        end
+        traverse.call(adapter_module::TestCase)
+      end
+    end
+  end
+end

data/lib/ruptr/timing_cache.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'zlib' # for crc32
+require 'pathname'
+
+require_relative 'sink'
+
+module Ruptr
+  class TimingCache
+    TIMING_CACHE_FILENAME = 'timing'
+
+    def initialize(state_dir, test_suite)
+      @state_path = Pathname(state_dir)
+      @test_suite = test_suite
+    end
+
+    attr_reader :test_suite
+
+    def timing_store
+      @timing_store ||= begin
+        @cache_path = @state_path / TIMING_CACHE_FILENAME
+        if @cache_path.exist?
+          TimingCache::Store.load(@test_suite, @cache_path)
+        else
+          TimingCache::Store.new
+        end
+      end
+    end
+
+    def save!(replace: true)
+      return unless @timing_store
+      @timing_store.dump(@test_suite, @cache_path, replace:)
+    end
+
+    class Store
+      def self.load(...) = new.tap { |o| o.load(...) }
+
+      def initialize
+        @current = {}
+      end
+
+      private def te_hash(te) = Zlib.crc32(te.description)
+
+      private def load_hashed(path)
+        s = Pathname(path).binread
+        n = s.length / 8
+        a = s.unpack("V#{n}e#{n}")
+        h = {}
+        n.times { |i| h[a[i]] = a[i + n] }
+        h
+      end
+
+      def load(ts, path)
+        h = load_hashed(path)
+
+        traverse = lambda do |tg|
+          total_time = 0
+          tg.each_test_case do |tc|
+            time = h[te_hash(tc)] or next
+            @current[tc] = time
+            total_time += time
+          end
+          tg.each_test_subgroup do |tg|
+            total_time += traverse.call(tg)
+          end
+          @current[tg] = total_time
+        end
+        traverse.call(ts)
+      end
+
+      private def dump_hashed(path, h)
+        n = h.size
+        s = (h.keys + h.values).pack("V#{n}e#{n}")
+        Pathname(path).binwrite(s)
+      end
+
+      def dump(_ts, path, replace: true)
+        h = replace ? {} : load_hashed(path)
+        @updated.each_pair do |te, time|
+          k = te_hash(te)
+          h[k] = [h[k] || 0, time].max
+        end
+        dump_hashed(path, h)
+      end
+
+      def [](te) = @current[te] || Float::INFINITY
+
+      include Sink
+
+      def begin_plan(_)
+        @updated = {}
+      end
+
+      def finish_case(tc, tr)
+        time = tr.processor_time
+        @updated[tc] = time if time
+      end
+    end
+  end
+end

data/lib/ruptr/tty_colors.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ruptr
+  class TTYColors
+    def self.probably_ansi_terminal?(io) = io.tty? && !['dumb', 'unknown', ''].include?(ENV.fetch('TERM', ''))
+    def self.want_cli_colors? = ENV.include?('CLICOLOR') || ENV.include?('LS_COLORS')
+    def self.for(io) = (want_cli_colors? && probably_ansi_terminal?(io) ? ANSICodes : Dummy).new
+
+    def self.seems_to_contain_formatting_codes?(s) = s.match?(/[\e\b]/)
+
+    class Dummy < self
+      def supports?(*args) = args.empty?
+      def wrap(s, **_opts) = s.to_s
+    end
+
+    class Overstrike < self
+      SUPPORTED = %i[bright underline].freeze
+
+      def supports?(*args) = args.all? { |name| SUPPORTED.include?(name) }
+
+      def wrap(s, bright: nil, underline: nil, **_opts)
+        s.to_s.chars.map { |c| %(#{c}#{bright ? "\b#{c}" : ''}#{underline ? "\b_" : ''}) }.join
+      end
+    end
+
+    class ANSICodes < self
+      SUPPORTED = %i[bright faint italic underline reverse strike overstrike].freeze
+      COLORS = %i[black red green yellow blue magenta cyan white].freeze
+
+      def supports?(*args)
+        args.all? do |name|
+          case name
+          when :color, :bg_color then COLORS.include?(name)
+          else SUPPORTED.include?(name)
+          end
+        end
+      end
+
+      def wrap(s, **opts)
+        b = +''; e = +''
+        if opts[:bright] then b << "\e[1m"; e << "\e[22m" end
+        if opts[:faint] then b << "\e[2m"; e << "\e[22m" end
+        if opts[:italic] then b << "\e[3m"; e << "\e[23m" end
+        if opts[:underline] then b << "\e[4m"; e << "\e[24m" end
+        if opts[:reverse] then b << "\e[7m"; e << "\e[27m" end
+        if opts[:strike] then b << "\e[9m"; e << "\e[29m" end
+        if opts[:overstrike] then b << "\e[53m"; e << "\e[55m" end
+        if (color_index = COLORS.find_index(opts[:color]))
+          b << "\e[#{30 + color_index}m"
+          e << "\e[39m"
+        end
+        if (color_index = COLORS.find_index(opts[:bg_color]))
+          b << "\e[#{40 + color_index}m"
+          e << "\e[49m"
+        end
+        "#{b}#{s}#{e}"
+      end
+    end
+  end
+end