test_bench 1.0.0.0

data/lib/test_bench/output/timer.rb

@@ -0,0 +1,75 @@
+module TestBench
+  module Output
+    class Timer
+      Error = Class.new(RuntimeError)
+
+      attr_accessor :start_time
+
+      def self.configure(receiver, attr_name: nil)
+        attr_name ||= :timer
+
+        instance = new
+        receiver.public_send(:"#{attr_name}=", instance)
+        instance
+      end
+
+      def start(now=nil)
+        now ||= ::Time.now.utc
+
+        if mode == Mode.running
+          raise Error, "Timer has already started (Start Time: #{start_time})"
+        end
+
+        self.start_time = now
+      end
+
+      def stop(now=nil)
+        now ||= ::Time.now.utc
+
+        if mode == Mode.stopped
+          raise Error, "Timer has not started"
+        end
+
+        start_time = reset
+
+        elapsed = now - start_time
+
+        elapsed.round(3)
+      end
+
+      def running?
+        mode == Mode.running
+      end
+
+      def stopped?
+        mode == Mode.stopped
+      end
+
+      def mode
+        if start_time.nil?
+          Mode.stopped
+        else
+          Mode.running
+        end
+      end
+
+      def reset
+        previous_start_time = self.start_time
+
+        self.start_time = nil
+
+        previous_start_time
+      end
+
+      module Mode
+        def self.running
+          :running
+        end
+
+        def self.stopped
+          :stopped
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module TestBench
+  module Output
+    class Timer
+      module Substitute
+        def self.build
+          Timer.new
+        end
+
+        class Timer < Timer
+          def elapsed_time
+            @elapsed_time ||= 0
+          end
+          attr_writer :elapsed_time
+
+          def mode
+            @mode ||= Mode.stopped
+          end
+          attr_writer :mode
+
+          def start(_=nil)
+            if mode == Mode.running
+              raise Error, "Timer has already started"
+            end
+
+            self.mode = Mode.running
+          end
+
+          def stop(_=nil)
+            if mode == Mode.stopped
+              raise Error, "Timer has not started"
+            end
+
+            self.mode = Mode.stopped
+
+            elapsed_time.round(3)
+          end
+
+          def set(elapsed_time)
+            self.elapsed_time = elapsed_time
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/output/writer.rb

@@ -0,0 +1,192 @@
+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_setting
+
+        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_setting
+          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/writer/dependency.rb

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,38 @@
+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/run.rb

@@ -0,0 +1,103 @@
+module TestBench
+  class Run
+    Error = Class.new(RuntimeError)
+
+    def session
+      @session ||= Session::Substitute.build
+    end
+    attr_writer :session
+
+    def exclude_file_pattern
+      @exclude_file_pattern ||= Defaults.exclude_file_pattern
+    end
+    attr_writer :exclude_file_pattern
+
+    attr_reader :paths
+
+    def initialize(*paths)
+      @paths = Array(paths)
+    end
+
+    def self.build(*paths, exclude_file_pattern: nil, session: nil, output: nil)
+      session ||= TestBench.session
+
+      instance = new(*paths)
+
+      instance.exclude_file_pattern = exclude_file_pattern unless exclude_file_pattern.nil?
+
+      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, **args, &block)
+      instance = build(*paths, **args)
+
+      if block.nil?
+        instance.()
+      else
+        instance.() do
+          block.(instance)
+        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_pattern].sort.each do |path|
+        next if exclude_file_pattern.match?(path)
+
+        file(path)
+      end
+    end
+
+    def file(path)
+      session.load(path)
+    end
+
+    module Defaults
+      def self.exclude_file_pattern
+        pattern = ENV.fetch('TEST_BENCH_EXCLUDE_FILE_PATTERN') do
+          '_init.rb$'
+        end
+
+        Regexp.new(pattern)
+      end
+    end
+  end
+end