test_bench 1.2.0.10 → 2.0.0.0.pre1

data/lib/test_bench/output/writer/dependency.rb

@@ -1,12 +0,0 @@
-module TestBench
-  module Output
-    class Writer
-      module Dependency
-        def writer
-          @writer ||= Substitute.build
-        end
-        attr_writer :writer
-      end
-    end
-  end
-end

data/lib/test_bench/output/writer/sgr.rb

@@ -1,54 +0,0 @@
-module TestBench
-  module Output
-    class Writer
-      module SGR
-        def self.escape_code(name)
-          assure_escape_code(name)
-
-          code_map.fetch(name)
-        end
-
-        def self.assure_escape_code(name)
-          unless code_map.key?(name)
-            raise Error, "Invalid escape code #{name.inspect} (Example values: #{code_map.keys.first(3).map(&:inspect).join(', ')})"
-          end
-        end
-
-        def self.code_map
-          @code_map ||= {
-            :reset => '0',
-
-            :bold => '1',
-            :faint => '2',
-            :italic => '3',
-            :underline => '4',
-
-            :reset_intensity => '22',
-            :reset_italic => '23',
-            :reset_underline => '24',
-
-            :black => '30',
-            :red => '31',
-            :green => '32',
-            :yellow => '33',
-            :blue => '34',
-            :magenta => '35',
-            :cyan => '36',
-            :white => '37',
-            :reset_fg => '39',
-
-            :black_bg => '40',
-            :red_bg => '41',
-            :green_bg => '42',
-            :yellow_bg => '43',
-            :blue_bg => '44',
-            :magenta_bg => '45',
-            :cyan_bg => '46',
-            :white_bg => '47',
-            :reset_bg => '49'
-          }
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/output/writer/substitute.rb

@@ -1,38 +0,0 @@
-module TestBench
-  module Output
-    class Writer
-      module Substitute
-        def self.build
-          writer = Writer.new
-          writer.styling_enabled = false
-          writer
-        end
-
-        class Writer < Writer
-          def written?(pattern=nil)
-            pattern = self.pattern(pattern)
-
-            written_text = device.string
-
-            pattern.match?(written_text)
-          end
-
-          def pattern(pattern)
-            case pattern
-            when nil
-              /./
-            when String
-              Regexp.new("\\A#{Regexp.escape(pattern)}\\z")
-            else
-              pattern
-            end
-          end
-
-          def enable_styling!
-            self.styling_enabled = true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/output/writer.rb

@@ -1,192 +0,0 @@
-module TestBench
-  module Output
-    class Writer
-      Error = Class.new(RuntimeError)
-
-      def device
-        @device ||= StringIO.new
-      end
-      attr_writer :device
-
-      attr_accessor :styling
-
-      def styling_enabled
-        instance_variable_defined?(:@styling_enabled) ?
-          @styling_enabled :
-          @styling_enabled = self.class.styling?(device, styling)
-      end
-      attr_writer :styling_enabled
-      alias_method :styling?, :styling_enabled
-
-      def mode
-        @mode ||= Mode.text
-      end
-      attr_writer :mode
-
-      def byte_offset
-        @byte_offset ||= 0
-      end
-      attr_writer :byte_offset
-
-      def indentation_depth
-        @indentation_depth ||= 0
-      end
-      attr_writer :indentation_depth
-
-      def configure(styling: nil, device: nil)
-        device ||= Defaults.device
-
-        unless styling.nil?
-          self.class.assure_styling_setting(styling)
-        end
-
-        self.device = device
-        self.styling = styling
-      end
-
-      def self.build(device=nil, styling: nil)
-        instance = new
-        instance.configure(device: device, styling: styling)
-        instance
-      end
-
-      def self.configure(receiver, writer: nil, styling: nil, device: nil, attr_name: nil)
-        attr_name ||= :writer
-
-        if writer.nil?
-          instance = build(device, styling: styling)
-        else
-          instance = writer
-        end
-
-        receiver.public_send(:"#{attr_name}=", instance)
-
-        instance
-      end
-
-      def text(text)
-        if mode == Mode.escape_sequence
-          self.mode = Mode.text
-
-          write('m')
-        end
-
-        write(text)
-
-        self
-      end
-
-      def escape_code(id)
-        escape_code = SGR.escape_code(id)
-
-        if mode == Mode.text
-          return self unless styling?
-
-          self.mode = Mode.escape_sequence
-
-          write("\e[")
-        else
-          write(';')
-        end
-
-        write(escape_code)
-
-        self
-      end
-
-      def sync
-        text('')
-      end
-
-      def indent
-        indentation = '  ' * indentation_depth
-
-        text(indentation)
-      end
-
-      def newline
-        sync
-        device.puts('')
-        self.byte_offset += 1
-        self
-      end
-
-      def write(data)
-        bytes_written = device.write(data)
-
-        self.byte_offset += bytes_written
-      end
-
-      def current?(byte_offset)
-        byte_offset >= self.byte_offset
-      end
-
-      def increase_indentation
-        self.indentation_depth += 1
-      end
-
-      def decrease_indentation
-        self.indentation_depth -= 1
-      end
-
-      def self.styling?(device, styling_setting=nil)
-        styling_setting ||= Defaults.styling
-
-        assure_styling_setting(styling_setting)
-
-        case styling_setting
-        when :detect
-          device.tty?
-        when :on
-          true
-        when :off
-          false
-        end
-      end
-
-      def self.assure_styling_setting(styling_setting)
-        unless styling_settings.include?(styling_setting)
-          raise Error, "Invalid output styling #{styling_setting.inspect} (Valid values: #{styling_settings.map(&:inspect).join(', ')})"
-        end
-      end
-
-      def self.styling_settings
-        [
-          :detect,
-          :on,
-          :off
-        ]
-      end
-
-      def self.default_styling_setting
-        styling_settings.fetch(0)
-      end
-
-      module Mode
-        def self.text
-          :text
-        end
-
-        def self.escape_sequence
-          :escape_sequence
-        end
-      end
-
-      module Defaults
-        def self.device
-          $stdout
-        end
-
-        def self.styling
-          styling = ::ENV['TEST_BENCH_OUTPUT_STYLING']
-
-          if styling.nil?
-            Writer.default_styling_setting
-          else
-            styling.to_sym
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/output.rb

@@ -1,21 +0,0 @@
-module TestBench
-  module Output
-    def self.build(log_level: nil, writer: nil, device: nil, styling: nil, **buffer_output_args)
-      summary = Summary.build(writer: writer, device: device, styling: styling)
-
-      log_output = Log.build(level: log_level)
-
-      writer = summary.writer
-
-      buffer_output = Buffer.build(writer: writer, **buffer_output_args)
-
-      Fixture::Output::Multiple.build(
-        log_output,
-        buffer_output,
-        summary
-      )
-    end
-
-    Substitute = Fixture::Output::Substitute
-  end
-end

data/lib/test_bench/run/substitute.rb

@@ -1,36 +0,0 @@
-module TestBench
-  class Run
-    module Substitute
-      def self.build
-        Run.new
-      end
-
-      class Run
-        attr_accessor :ran
-
-        def paths
-          @paths ||= []
-        end
-
-        def call(&block)
-          self.ran = true
-
-          block.(self) unless block.nil?
-        end
-
-        def path(path)
-          paths << path
-        end
-        alias_method :<<, :path
-
-        def ran?(*paths)
-          return false unless ran
-
-          paths.all? do |path|
-            self.paths.include?(path)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/run.rb

@@ -1,113 +0,0 @@
-module TestBench
-  class Run
-    Error = Class.new(RuntimeError)
-
-    def session
-      @session ||= Fixture::Session::Substitute.build
-    end
-    attr_writer :session
-
-    def exclude_pattern
-      @exclude_pattern ||= Defaults.exclude_pattern
-    end
-    attr_writer :exclude_pattern
-
-    attr_reader :paths
-
-    def initialize(*paths)
-      @paths = Array(paths)
-    end
-
-    def self.build(*paths, exclude: nil, session: nil, output: nil)
-      session ||= TestBench.session
-
-      instance = new(*paths)
-
-      instance.exclude_pattern = exclude unless exclude.nil?
-
-      Fixture::Session.configure(instance, session: session)
-      instance.session.output = output unless output.nil?
-
-      instance
-    end
-
-    def self.configure(receiver, *paths, attr_name: nil, **args)
-      attr_name ||= :run
-
-      instance = build(*paths, **args)
-      receiver.public_send(:"#{attr_name}=", instance)
-      instance
-    end
-
-    def self.call(*paths, session: nil, **args, &block)
-      instance = build(*paths, session: session, **args)
-
-      if block.nil?
-        instance.()
-      else
-        instance.() do
-          unless session.nil?
-            original_session = TestBench.session
-            TestBench.session = session
-          end
-
-          block.(instance)
-
-        ensure
-          unless original_session.nil?
-            TestBench.session = original_session
-          end
-        end
-      end
-    end
-
-    def call(&block)
-      session.start
-
-      if block.nil?
-        paths.each do |path|
-          path(path)
-        end
-      else
-        block.()
-      end
-
-    ensure
-      session.finish
-    end
-
-    def path(path)
-      if File.directory?(path)
-        directory(path)
-      elsif File.exist?(path)
-        file(path)
-      else
-        raise Error, "Path not found (Path: #{path.inspect})"
-      end
-    end
-
-    def directory(path)
-      glob_pattern = File.join(path, '**/*.rb')
-
-      Dir.glob(glob_pattern).sort.each do |path|
-        file(path)
-      end
-    end
-
-    def file(path)
-      unless exclude_pattern.match?(path)
-        session.load(path)
-      end
-    end
-
-    module Defaults
-      def self.exclude_pattern
-        pattern = ENV.fetch('TEST_BENCH_EXCLUDE_FILE_PATTERN') do
-          '_init.rb$'
-        end
-
-        Regexp.new(pattern)
-      end
-    end
-  end
-end

data/script/bench

@@ -1,19 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require 'test_bench'
-rescue LoadError => load_error
-end
-
-unless load_error.nil?
-  if File.exist?('init.rb')
-    require_relative '../init.rb'
-    require 'test_bench'
-
-    ENV['BOOTSTRAP'] ||= 'off'
-  else
-    raise load_error
-  end
-end
-
-TestBench::CLI.()