test_bench-bootstrap 2.1.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce89e18ca0c6494f546f09c4b8786d7aca2e2bdc435c74b9a0a6cb2786f86481
-  data.tar.gz: bba0af0bcee52f86fbb2e58aaa589d8ba7f847ce8cf0e86e08c0b7d086fc381b
+  metadata.gz: b4e2e358c29830ece30c5a9516c4cf96fe2d6748cb1a3c88e9d3d05727c66f9a
+  data.tar.gz: d07c4e27d9c6440427ff716ff8fe6cf405940287417c5f0f69e90560d6c140da
 SHA512:
-  metadata.gz: 7631713647f4c2199926af78af8e509fbb96ba247fcee7c20e6b12cacf48307eb26244acc5b2e9522e40c093e8f5d6d1bba52acec8c47e92db15a50facd32b3d
-  data.tar.gz: 88944e3be2c9fdd414fd22a5e8ce18e70fdbe840b2482919a68225c8b43d757d748617bb8086628a890a4b60d35e25a0cf56ccf23d5246143d35c8c0ec6dd261
+  metadata.gz: 787ba756e146d4b72a0a7dd265df1baa3c4ddab27bf78e3e0d271dd1b333a7006e1e486b0369c9727ffed7bf15adb9e150fe8a13b7f743b2833a0b78ee9cf881
+  data.tar.gz: faf41a1355cf5cc3a20cc46aa25cd1e1b62b4bb69da66ef25bc20b2efdacabdfe6d0f736908120f6ecab24f7b011d4ecee36bfa94ce78d0271da878260023681

data/lib/test_bench/bootstrap.rb

@@ -4,15 +4,94 @@ module TestBench
       Object.include(Fixture)
     end
 
+    if RUBY_ENGINE != 'mruby'
+      class Abort < SystemExit
+        def self.build
+          new(1)
+        end
+      end
+    end
+
+    class Abort
+      def self.call
+        Output.raw_write("#{Bootstrap} is aborting\n")
+        instance = build
+        raise instance
+      end
+    end
+
+    module Backtrace
+      if RUBY_ENGINE != 'mruby'
+        def self.frame(frame_index)
+          frame_index += 1
+
+          caller[frame_index]
+        end
+      end
+    end
+
+    class AssertionFailure < RuntimeError
+      def self.build(frame_index=nil)
+        frame_index ||= 0
+
+        frame = Backtrace.frame(frame_index)
+
+        instance = new
+        instance.set_backtrace([frame])
+        instance
+      end
+
+      def message
+        "Assertion failed"
+      end
+    end
+
+    module Path
+      if RUBY_ENGINE != 'mruby'
+        def self.match?(pattern, string)
+          ::File.fnmatch?(pattern, string)
+        end
+
+        def self.search(path, include_pattern=nil, exclude_pattern=nil)
+          files = []
+
+          if ::File.directory?(path)
+            search_directory(path, files, include_pattern, exclude_pattern)
+          elsif ::File.exist?(path)
+            files << path
+          else
+            raise LoadError, "no such file or directory -- #{path}"
+          end
+
+          files
+        end
+
+        def self.search_directory(dir, files, include_pattern=nil, exclude_pattern=nil)
+          include_pattern ||= '*.rb'
+
+          ::Dir[::File.join(dir, '**', '*')].each do |path|
+            next if ::File.directory?(path)
+
+            if match?(include_pattern, path)
+              if exclude_pattern.nil? || !match?(exclude_pattern, path)
+                files << path
+              end
+            end
+          end
+        end
+      end
+    end
+
     module Fixture
       def assert(value)
         unless value
-          raise AssertionFailure.build(caller.first)
+          raise AssertionFailure.build(1)
         end
       end
 
       def assert_raises(error_class=nil, &block)
         begin
+          Output.raw_write("assert_raises\n")
           block.()
 
         rescue (error_class || StandardError) => error
@@ -25,12 +104,12 @@ module TestBench
           end
         end
 
-        raise AssertionFailure.build(caller.first)
+        raise AssertionFailure.build(1)
       end
 
       def refute(value)
         if value
-          raise AssertionFailure.build(caller.first)
+          raise AssertionFailure.build(1)
         end
       end
 
@@ -42,7 +121,7 @@ module TestBench
           raise error
         end
 
-        raise AssertionFailure.build(caller.first)
+        raise AssertionFailure.build(1)
       end
 
       def context(prose=nil, &block)
@@ -62,9 +141,9 @@ module TestBench
           block.()
 
         rescue => error
-          Fixture.print_error(error)
+          Output.error(error)
 
-          raise Failure.build
+          Abort.()
         end
       end
 
@@ -85,10 +164,10 @@ module TestBench
 
         rescue => error
           Output.indent(prose, sgr_codes: [0x1, 0x31]) do
-            Fixture.print_error(error)
+            Output.error(error)
           end
 
-          raise Failure.build
+          Abort.()
         end
       end
 
@@ -100,6 +179,10 @@ module TestBench
         Output.write(text)
       end
 
+      def detail(text)
+        comment(text)
+      end
+
       def fixture(cls, *args, **kwargs, &block)
         fixture = TestBench::Fixture.(cls, *args, **kwargs, &block)
 
@@ -107,66 +190,79 @@ module TestBench
 
         assert(passed)
       end
+    end
+
+    module Output
+      extend self
+
+      def write(text, device: nil, sgr_code: nil, sgr_codes: nil, tab_indent: nil)
+        indent(text, device: device, sgr_code: sgr_code, sgr_codes: sgr_codes, tab_indent: tab_indent)
+      end
 
-      def self.print_error(error)
-        omit_backtrace_pattern = ENV['TEST_BENCH_OMIT_BACKTRACE_PATTERN']
-        omit_backtrace_pattern ||= %r{test_bench/bootstrap\.rb}
+      def error(error)
+        omit_backtrace_pattern = Defaults.omit_backtrace_pattern
 
         omitting = false
 
-        Output.write("\e[1mTraceback\e[22m (most recent call last):", sgr_code: 0x31)
+        write("\e[1mTraceback\e[22m (most recent call last):", sgr_code: 0x31)
 
         rjust_length = error.backtrace.length.to_s.length
 
-        error.backtrace[1..-1].reverse_each.with_index do |line, index|
-          line = line.dup
+        reverse_backtrace = error.backtrace[1..-1].reverse
 
-          line.chomp!
+        reverse_backtrace.each_with_index do |frame, index|
+          frame = frame.dup
+          frame.chomp!
 
-          if omit_backtrace_pattern.match?(line)
+          previous_frame = frame
+
+          file, _ = frame.split(':', 2)
+
+          line = ' ' * rjust_length
+
+          index_text = index.to_s
+          index_range = (-index_text.length..-1)
+
+          if Path.match?(omit_backtrace_pattern, file)
             if omitting
               next
             else
               omitting = true
 
-              header = index.to_s.gsub(/./, '?').rjust(rjust_length, ' ')
+              line[index_range] = '?' * index_text.length
+              line += ": *omitted*"
 
-              Output.write("#{header}: *omitted*", sgr_codes: [0x2, 0x3, 0x31], tab_indent: true)
+              write(line, sgr_codes: [0x2, 0x3, 0x31], tab_indent: true)
             end
           else
             omitting = false
 
-            header = index.to_s.rjust(rjust_length, ' ')
+            line[index_range] = index_text
+            line += ": #{frame}"
 
-            Output.write("#{header}: #{line}", sgr_code: 0x31, tab_indent: true)
+            write(line, sgr_code: 0x31, tab_indent: true)
           end
         end
 
         if error.message.empty?
           if error.instance_of?(RuntimeError)
-            Output.write("#{error.backtrace[0]}: \e[1;4munhandled exception\e[24;22m", sgr_code: 0x31)
+            write("#{error.backtrace[0]}: \e[1;4munhandled exception\e[24;22m", sgr_code: 0x31)
             return
           end
 
           error.message = error.class
         end
 
-        Output.write("#{error.backtrace[0]} \e[1m#{error} (\e[4m#{error.class}\e[24m)\e[22m", sgr_code: 0x31)
+        write("#{error.backtrace[0]}: \e[1m#{error} (\e[4m#{error.class}\e[24m)\e[22m", sgr_code: 0x31)
       end
-    end
 
-    module Output
-      extend self
-
-      def write(text, device: nil, sgr_code: nil, sgr_codes: nil, tab_indent: nil)
-        indent(text, device: device, sgr_code: sgr_code, sgr_codes: sgr_codes, tab_indent: tab_indent)
+      def newline
+        write('')
       end
 
       def indent(text, device: nil, sgr_code: nil, sgr_codes: nil, tab_indent: nil, &block)
-        device ||= $stdout
-
         unless text.nil?
-          sgr_codes = Array(sgr_codes)
+          sgr_codes ||= []
           unless sgr_code.nil?
             sgr_codes << sgr_code
           end
@@ -179,9 +275,9 @@ module TestBench
             text = "\e[#{sgr_codes.join(';')}m#{text}\e[0m"
           end
 
-          text = "#{"\t" if tab_indent}#{'  ' * indentation}#{text}"
+          text = "#{"\t" if tab_indent}#{'  ' * indentation}#{text}\n"
 
-          device.puts(text)
+          raw_write(text, device)
         end
 
         return if block.nil?
@@ -195,67 +291,83 @@ module TestBench
         end
       end
 
-      def indentation
-        @indentation ||= 0
-      end
-      attr_writer :indentation
-    end
+      def raw_write(text, device=nil)
+        device ||= self.device
 
-    class AssertionFailure < RuntimeError
-      def self.build(caller_location=nil)
-        caller_location ||= caller(0)
-
-        instance = new
-        instance.set_backtrace([caller_location])
-        instance
+        device.write(text)
       end
 
-      def message
-        "Assertion failed"
+      def indentation
+        @indentation ||= 0
       end
-    end
+      attr_writer :indentation
 
-    class Failure < SystemExit
-      def self.build
-        new(1, "TestBench::Bootstrap is aborting")
+      def device
+        @device ||= Defaults.output_device
       end
     end
 
     module Run
-      def self.call(argv=nil, exclude_file_pattern: nil)
-        argv ||= ::ARGV
-
-        exclude_file_pattern = ENV['TEST_BENCH_EXCLUDE_FILE_PATTERN']
-        exclude_file_pattern ||= %r{automated_init\.rb}
+      def self.call(paths=nil, exclude_pattern: nil)
+        paths ||= []
+        exclude_pattern ||= Defaults.exclude_file_pattern
 
-        if argv.empty?
-          tests_dir = ENV['TEST_BENCH_TESTS_DIR'] || 'test/automated'
-
-          file_patterns = [File.join(tests_dir, '**', '*.rb')]
-        else
-          file_patterns = argv
+        if paths.is_a?(String)
+          paths = [paths]
         end
 
-        file_patterns.each do |file_pattern|
-          if File.directory?(file_pattern)
-            file_pattern = File.join(file_pattern, '**/*.rb')
-          end
-
-          files = Dir.glob(file_pattern).reject do |file|
-            File.basename(file).match?(exclude_file_pattern)
-          end
+        if paths.empty?
+          paths << Defaults.tests_dir
+        end
 
-          files.sort.each do |file|
-            puts "Running #{file}"
+        paths.each do |path|
+          Path.search(path, '*.rb', exclude_pattern).each do |file|
+            Output.write "Running #{file}"
 
             begin
-              load file
+              load(file)
             ensure
-              puts
+              Output.newline
             end
           end
         end
       end
     end
+
+    module Defaults
+      def self.get(env_var, default)
+        if env.key?(env_var)
+          env[env_var]
+        else
+          default
+        end
+      end
+
+      def self.exclude_file_pattern
+        get('TEST_BENCH_EXCLUDE_FILE_PATTERN', '*_init.rb')
+      end
+
+      def self.omit_backtrace_pattern
+        get('TEST_BENCH_OMIT_BACKTRACE_PATTERN', '*/test_bench/bootstrap.rb')
+      end
+
+      def self.tests_dir
+        get('TEST_BENCH_TESTS_DIRECTORY', 'test/automated')
+      end
+
+      if RUBY_ENGINE == 'mruby'
+        def self.env
+          {}
+        end
+      else
+        def self.output_device
+          $stdout
+        end
+
+        def self.env
+          ::ENV
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_bench-bootstrap
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Nathan Ladd
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-10 00:00:00.000000000 Z
+date: 2022-08-25 00:00:00.000000000 Z
 dependencies: []
 description:
 email: nathanladd+github@gmail.com
@@ -36,7 +36,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.4
 signing_key:
 specification_version: 4
 summary: A minimal test framework for testing TestBench