test_bench-bootstrap 3.0.0.0.pre.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea0908671f33eee6a5668952c486c5e2e6272d8e6fa878175dd331104626ba63
-  data.tar.gz: 6e846123a4d565e621c86920537a34b330aa389b543b29a49110b1cbe9c6f21c
+  metadata.gz: b4e2e358c29830ece30c5a9516c4cf96fe2d6748cb1a3c88e9d3d05727c66f9a
+  data.tar.gz: d07c4e27d9c6440427ff716ff8fe6cf405940287417c5f0f69e90560d6c140da
 SHA512:
-  metadata.gz: 6ed3a6700020d6efc57b90ded1305b3d293d0936e490ba602d51b764ee1d9499d1a965c20dc41d9dffd96e15d8f651aac7ed3e68e4fdd25f3f8d767b8ed948d6
-  data.tar.gz: ed43a134a45f23bad998d062c94514035a95e6df45b0a43a483f5b92d1b4e6717f2eb2c825d4dceccb39581d6d50e73e1cae95e2f2d77d23eb8c02ca7c86c36b
+  metadata.gz: 787ba756e146d4b72a0a7dd265df1baa3c4ddab27bf78e3e0d271dd1b333a7006e1e486b0369c9727ffed7bf15adb9e150fe8a13b7f743b2833a0b78ee9cf881
+  data.tar.gz: faf41a1355cf5cc3a20cc46aa25cd1e1b62b4bb69da66ef25bc20b2efdacabdfe6d0f736908120f6ecab24f7b011d4ecee36bfa94ce78d0271da878260023681

data/lib/test_bench/bootstrap.rb

@@ -0,0 +1,373 @@
+module TestBench
+  module Bootstrap
+    def self.activate
+      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(1)
+        end
+      end
+
+      def assert_raises(error_class=nil, &block)
+        begin
+          Output.raw_write("assert_raises\n")
+          block.()
+
+        rescue (error_class || StandardError) => error
+          return if error_class.nil?
+
+          if error.instance_of?(error_class)
+            return
+          else
+            raise error
+          end
+        end
+
+        raise AssertionFailure.build(1)
+      end
+
+      def refute(value)
+        if value
+          raise AssertionFailure.build(1)
+        end
+      end
+
+      def refute_raises(error_class=nil, &block)
+        block.()
+
+      rescue (error_class || StandardError) => error
+        unless error.instance_of?(error_class)
+          raise error
+        end
+
+        raise AssertionFailure.build(1)
+      end
+
+      def context(prose=nil, &block)
+        if block.nil?
+          Output.write(prose || 'Context', sgr_code: 0x33)
+          return
+        end
+
+        unless prose.nil?
+          Output.indent(prose, sgr_code: 0x32) do
+            context(&block)
+          end
+          return
+        end
+
+        begin
+          block.()
+
+        rescue => error
+          Output.error(error)
+
+          Abort.()
+        end
+      end
+
+      def _context(prose=nil, &block)
+        context(prose)
+      end
+
+      def test(prose=nil, &block)
+        if block.nil?
+          Output.write(prose || 'Test', sgr_code: 0x33)
+          return
+        end
+
+        begin
+          block.()
+
+          Output.indent(prose, sgr_code: 0x32)
+
+        rescue => error
+          Output.indent(prose, sgr_codes: [0x1, 0x31]) do
+            Output.error(error)
+          end
+
+          Abort.()
+        end
+      end
+
+      def _test(prose=nil, &block)
+        test(prose)
+      end
+
+      def comment(text)
+        Output.write(text)
+      end
+
+      def detail(text)
+        comment(text)
+      end
+
+      def fixture(cls, *args, **kwargs, &block)
+        fixture = TestBench::Fixture.(cls, *args, **kwargs, &block)
+
+        passed = !fixture.test_session.failed?
+
+        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 error(error)
+        omit_backtrace_pattern = Defaults.omit_backtrace_pattern
+
+        omitting = false
+
+        write("\e[1mTraceback\e[22m (most recent call last):", sgr_code: 0x31)
+
+        rjust_length = error.backtrace.length.to_s.length
+
+        reverse_backtrace = error.backtrace[1..-1].reverse
+
+        reverse_backtrace.each_with_index do |frame, index|
+          frame = frame.dup
+          frame.chomp!
+
+          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
+
+              line[index_range] = '?' * index_text.length
+              line += ": *omitted*"
+
+              write(line, sgr_codes: [0x2, 0x3, 0x31], tab_indent: true)
+            end
+          else
+            omitting = false
+
+            line[index_range] = index_text
+            line += ": #{frame}"
+
+            write(line, sgr_code: 0x31, tab_indent: true)
+          end
+        end
+
+        if error.message.empty?
+          if error.instance_of?(RuntimeError)
+            write("#{error.backtrace[0]}: \e[1;4munhandled exception\e[24;22m", sgr_code: 0x31)
+            return
+          end
+
+          error.message = error.class
+        end
+
+        write("#{error.backtrace[0]}: \e[1m#{error} (\e[4m#{error.class}\e[24m)\e[22m", sgr_code: 0x31)
+      end
+
+      def newline
+        write('')
+      end
+
+      def indent(text, device: nil, sgr_code: nil, sgr_codes: nil, tab_indent: nil, &block)
+        unless text.nil?
+          sgr_codes ||= []
+          unless sgr_code.nil?
+            sgr_codes << sgr_code
+          end
+
+          unless sgr_codes.empty?
+            sgr_codes.map! do |sgr_code|
+              sgr_code.to_s(16)
+            end
+
+            text = "\e[#{sgr_codes.join(';')}m#{text}\e[0m"
+          end
+
+          text = "#{"\t" if tab_indent}#{'  ' * indentation}#{text}\n"
+
+          raw_write(text, device)
+        end
+
+        return if block.nil?
+
+        self.indentation += 1 unless text.nil?
+
+        begin
+          block.()
+        ensure
+          self.indentation -= 1 unless text.nil?
+        end
+      end
+
+      def raw_write(text, device=nil)
+        device ||= self.device
+
+        device.write(text)
+      end
+
+      def indentation
+        @indentation ||= 0
+      end
+      attr_writer :indentation
+
+      def device
+        @device ||= Defaults.output_device
+      end
+    end
+
+    module Run
+      def self.call(paths=nil, exclude_pattern: nil)
+        paths ||= []
+        exclude_pattern ||= Defaults.exclude_file_pattern
+
+        if paths.is_a?(String)
+          paths = [paths]
+        end
+
+        if paths.empty?
+          paths << Defaults.tests_dir
+        end
+
+        paths.each do |path|
+          Path.search(path, '*.rb', exclude_pattern).each do |file|
+            Output.write "Running #{file}"
+
+            begin
+              load(file)
+            ensure
+              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