test_bench_legacy 1.3.5

data/lib/test_bench/executor.rb

@@ -0,0 +1,45 @@
+module TestBench
+  class Executor
+    attr_reader :binding
+    attr_reader :kernel
+
+    def initialize binding, kernel
+      @binding = binding
+      @kernel = kernel
+    end
+
+    def self.build
+      binding = TOPLEVEL_BINDING
+
+      new binding, Kernel
+    end
+
+    def call files
+      files.each do |file|
+        execute file
+      end
+
+      telemetry.passed?
+    end
+
+    def execute file
+      telemetry.file_started file
+
+      begin
+        unbound_context_method = TestBench::Structure.instance_method :context
+        bound_context_method = unbound_context_method.bind binding.receiver
+
+        bound_context_method.call :suppress_exit => true do
+          kernel.load File.expand_path file
+        end
+
+      ensure
+        telemetry.file_finished file
+      end
+    end
+
+    def telemetry
+      Telemetry::Registry.get binding
+    end
+  end
+end

data/lib/test_bench/expand_path.rb

@@ -0,0 +1,44 @@
+module TestBench
+  class ExpandPath
+    attr_reader :dir
+    attr_reader :exclude_pattern
+    attr_reader :root_directory
+
+    def initialize root_directory, exclude_pattern, dir
+      @dir = dir
+      @exclude_pattern = exclude_pattern
+      @root_directory = root_directory
+    end
+
+    def self.build root_directory, exclude_pattern=nil, dir: nil
+      dir ||= Dir
+
+      exclude_pattern ||= Settings.toplevel.exclude_pattern
+      exclude_pattern = Regexp.new exclude_pattern if exclude_pattern.is_a? String
+
+      root_directory = Pathname root_directory
+
+      new root_directory, exclude_pattern, dir
+    end
+
+    def call pattern
+      full_pattern = root_directory.join pattern
+
+      if dir.exist? full_pattern
+        full_pattern = full_pattern.join '**/*.rb'
+      end
+
+      expand full_pattern.to_s
+    end
+
+    def expand full_pattern
+      dir[full_pattern].flat_map do |file|
+        if exclude_pattern.match file
+          []
+        else
+          [file]
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/fixture.rb

@@ -0,0 +1,17 @@
+module TestBench
+  module Fixture
+    def self.included cls
+      cls.class_exec do
+        extend Forwardable
+
+        delegate %i(assert comment context refute test) => :structure
+      end
+    end
+
+    attr_writer :structure
+
+    def structure
+      @structure ||= TOPLEVEL_BINDING.receiver
+    end
+  end
+end

data/lib/test_bench/output.rb

@@ -0,0 +1,169 @@
+module TestBench
+  class Output
+    attr_writer :file_result
+    attr_writer :reverse_backtraces
+    attr_writer :run_result
+    attr_writer :writer
+
+    def initialize
+      @file_result = nil
+    end
+
+    def self.build level=nil
+      writer = Writer.build $stdout
+      writer.level = level if level
+
+      instance = new
+      instance.writer = writer
+      instance
+    end
+
+    def asserted
+      file_result.asserted
+      run_result.asserted
+    end
+
+    def commented prose
+      writer.normal prose, :fg => :normal
+    end
+
+    def context_entered prose=nil
+      return if prose.nil?
+
+      writer.normal prose, :fg => :green
+
+      writer.increase_indentation unless writer.level == :quiet
+    end
+
+    def context_exited prose=nil
+      return if prose.nil?
+
+      writer.decrease_indentation unless writer.level == :quiet
+
+      writer.normal ' ' if writer.indentation.zero?
+    end
+
+    def device
+      @device ||= StringIO.new
+    end
+
+    def error_raised error
+      run_result.error_raised error
+      file_result.error_raised error
+
+      detail_summary = "#{error.backtrace[0]}: #{error.message} (#{error.class})"
+
+      lines = [detail_summary]
+      error.backtrace[1..-1].each do |frame|
+        lines << "        from #{frame}"
+      end
+
+      lines.reverse! if reverse_backtraces
+
+      lines.each do |line|
+        writer.quiet line, :fg => :red
+      end
+    end
+
+    def file_finished path
+      run_result.file_finished path
+      file_result.finished
+
+      summary = summarize_result file_result
+
+      self.file_result = nil
+
+      writer.verbose "Finished running #{path}"
+      writer.verbose summary
+      writer.verbose ' '
+    end
+
+    def file_result
+      @file_result or Result::Null
+    end
+
+    def file_started path
+      writer.normal "Running #{path}"
+
+      file_result = Result.build
+
+      self.file_result = file_result
+
+      file_result
+    end
+
+    def reverse_backtraces
+      ivar = :@reverse_backtraces
+
+      if instance_variable_defined? ivar
+        instance_variable_get ivar
+      else
+        instance_variable_set ivar, false
+      end
+    end
+
+    def run_finished
+      run_result.run_finished
+
+      files_label = if run_result.files.size == 1 then 'file' else 'files' end
+
+      color = if run_result.passed? then :cyan else :red end
+
+      writer.quiet "Finished running #{run_result.files.size} #{files_label}"
+
+      summary = summarize_result run_result
+
+      writer.quiet summary, :fg => color
+    end
+
+    def run_started
+      self.run_result
+    end
+
+    def run_result
+      @run_result ||= Result.build
+    end
+
+    def summarize_result result
+      minutes, seconds = result.elapsed_time.divmod 60
+
+      elapsed = String.new
+      elapsed << "#{minutes}m" unless minutes.zero?
+      elapsed << "%.3fs" % seconds
+
+      test_label = if result.tests == 1 then 'test' else 'tests' end
+      error_label = if result.errors == 1 then 'error' else 'errors' end
+      "Ran %d #{test_label} in #{elapsed} (%.3fs tests/second)\n%d passed, %d skipped, %d failed, %d total #{error_label}" %
+        [result.tests, result.tests_per_second, result.passes, result.skips, result.failures, result.errors]
+    end
+
+    def test_failed prose
+      file_result.test_failed prose
+      run_result.test_failed prose
+
+      writer.quiet prose, :fg => :white, :bg => :red
+    end
+
+    def test_passed prose
+      file_result.test_passed prose
+      run_result.test_passed prose
+
+      writer.normal prose, :fg => :green
+    end
+
+    def test_skipped prose
+      file_result.test_skipped prose
+      run_result.test_skipped prose
+
+      writer.normal prose, :fg => :brown
+    end
+
+    def test_started prose
+      writer.verbose "Started test #{prose.inspect}", :fg => :gray
+    end
+
+    def writer
+      @writer ||= Writer.new
+    end
+  end
+end

data/lib/test_bench/output/assertions.rb

@@ -0,0 +1,43 @@
+module TestBench
+  class Output
+    module Assertions
+      def color_output?
+        text = 'Some Text'
+        color = :gray
+
+        write text, :fg => color, :bg => color
+
+        wrote_line? text, :fg => color, :bg => color
+      end
+
+      def text_written
+        device.rewind
+        device.read
+      end
+
+      def wrote? text
+        text_written == text
+      end
+
+      def wrote_line? text, indent: nil, **colors
+        color ||= {}
+        indent ||= 0
+
+        color_escape = Palette.escape_code(**colors)
+        unless color_escape.empty?
+          text = "#{color_escape}#{text}\e[0m"
+        end
+
+        matcher = Regexp.escape "#{'  ' * indent}#{text}"
+
+        pattern = /^#{matcher}$/n
+
+        pattern.match text_written
+      end
+
+      def wrote_nothing?
+        text_written.empty?
+      end
+    end
+  end
+end

data/lib/test_bench/output/palette.rb

@@ -0,0 +1,59 @@
+module TestBench
+  class Output
+    module Palette
+      def self.apply prose, **colors
+        escape_code = self.escape_code(**colors)
+
+        if escape_code.empty?
+          prose
+        else
+          "#{escape_code}#{prose}\e[0m"
+        end
+      end
+
+      def self.escape_code fg: nil, bg: nil
+        return '' if fg.nil? and bg.nil?
+
+        brightness, fg = get fg if fg
+        _, bg = get bg if bg
+
+        str = String.new "\e["
+
+        str << "#{brightness};3#{fg}" if fg
+        str << ';' if fg and bg
+        str << "4#{bg}" if bg
+        str << 'm'
+
+        str
+      end
+
+      def self.get name
+        code = names.index name
+        return unless code
+        brightness, code = code.divmod 8
+        return brightness, code
+      end
+
+      def self.names
+        @names ||= %i(
+          black
+          red
+          green
+          brown
+          blue
+          magenta
+          cyan
+          gray
+          dark_gray
+          bright_red
+          bright_green
+          yellow
+          bright_blue
+          bright_magenta
+          bright_cyan
+          white
+        )
+      end
+    end
+  end
+end

data/lib/test_bench/output/writer.rb

@@ -0,0 +1,94 @@
+module TestBench
+  class Output
+    class Writer
+      attr_accessor :color
+      attr_writer :device
+      attr_accessor :indentation
+      attr_writer :level
+      attr_reader :mutex
+
+      def initialize level=nil
+        @level = level
+        @indentation = 0
+        @mutex = Mutex.new
+      end
+
+      def self.build device
+        instance = new
+        instance.device = device
+        instance
+      end
+
+      def color?
+        return color unless color.nil?
+        device.tty?
+      end
+
+      def decrease_indentation
+        mutex.synchronize do
+          self.indentation -= 1
+        end
+      end
+
+      def device
+        @device ||= StringIO.new
+      end
+
+      def increase_indentation
+        mutex.synchronize do
+          self.indentation += 1
+        end
+      end
+
+      def level
+        @level ||= :normal
+      end
+
+      def lower_verbosity
+        if level == :verbose
+          self.level = :normal
+        elsif level == :normal
+          self.level = :quiet
+        end
+      end
+
+      def normal prose, **arguments
+        arguments[:render] = false if level == :quiet
+        write prose, **arguments
+      end
+
+      def quiet prose, **arguments
+        write prose, **arguments
+      end
+
+      def raise_verbosity
+        if level == :quiet
+          self.level = :normal
+        elsif level == :normal
+          self.level = :verbose
+        end
+      end
+
+      def verbose prose, **arguments
+        arguments[:render] = false unless level == :verbose
+        write prose, **arguments
+      end
+
+      def write prose, bg: nil, fg: nil, render: nil
+        render = true if render.nil?
+
+        if render
+          text = String.new prose
+
+          indentation = '  ' * self.indentation
+
+          prose = Palette.apply prose, bg: bg, fg: fg if color?
+
+          text = "#{indentation}#{prose}#{$INPUT_RECORD_SEPARATOR}"
+
+          device.write text
+        end
+      end
+    end
+  end
+end