aruba 0.6.2 → 0.7.0

data/lib/aruba/processes/basic_process.rb

@@ -0,0 +1,25 @@
+module Aruba
+  module Processes
+    class BasicProcess
+      def initialize(cmd, exit_timeout, io_wait, working_directory)
+        @working_directory = working_directory
+      end
+
+      # Output stderr and stdout
+      def output
+        stdout + stderr
+      end
+
+      # Was process already stopped
+      def stopped?
+        @stopped == true
+      end
+
+      # Hook which is run before command is run
+      def before_run; end
+
+      # Hook which is run after command is run
+      def after_run; end
+    end
+  end
+end

data/lib/aruba/processes/debug_process.rb

@@ -0,0 +1,59 @@
+require 'aruba/processes/spawn_process'
+
+module Aruba
+  module Processes
+    # Create process
+    #
+    # @params [String] cmd
+    #   Command string
+    #
+    # @params [Integer] exit_timeout
+    #   The timeout until we expect the command to be finished
+    #
+    # @params [Integer] io_wait
+    #   The timeout until we expect the io to be finished
+    #
+    # @params [String] working_directory
+    #   The directory where the command will be executed
+    class DebugProcess < BasicProcess
+      attr_reader :exit_status
+
+      # @see SpawnProcess
+      def initialize(cmd, _exit_timeout, _io_wait, working_directory)
+        @cmd               = cmd
+        @working_directory = working_directory
+
+        super
+      end
+
+      # Return command line
+      def commandline
+        @cmd
+      end
+
+      def run!
+        @exit_status = system(@cmd, chdir: @working_directory) ? 0 : 1
+      end
+
+      def stdin(*); end
+
+      def stdout(*)
+        ''
+      end
+
+      def stderr(*)
+        ''
+      end
+
+      def stop(_reader)
+        @stopped = true
+
+        @exit_status
+      end
+
+      def terminate(*)
+        stop
+      end
+    end
+  end
+end

data/lib/aruba/processes/in_process.rb

@@ -0,0 +1,86 @@
+require 'shellwords'
+require 'stringio'
+require 'aruba/processes/basic_process'
+
+module Aruba
+  module Processes
+    class InProcess < BasicProcess
+      attr_reader :exit_status
+
+      class FakeKernel
+        attr_reader :exitstatus
+
+        def initialize
+          @exitstatus = 0
+        end
+
+        def exit(exitstatus)
+          @exitstatus = exitstatus
+        end
+      end
+
+      class << self
+        attr_accessor :main_class
+      end
+
+      def initialize(cmd, exit_timeout, io_wait, working_directory)
+        args               = Shellwords.split(cmd)
+        @argv              = args[1..-1]
+        @stdin             = StringIO.new
+        @stdout            = StringIO.new
+        @stderr            = StringIO.new
+        @kernel            = FakeKernel.new
+
+        super
+      end
+
+      # Return the commandline
+      def commandline
+        self.class.main_class.to_s + @argv.join(" ")
+      end
+
+      def run!
+        raise "You need to call Aruba::InProcess.main_class = YourMainClass" unless self.class.main_class
+
+        Dir.chdir @working_directory do
+          before_run
+          self.class.main_class.new(@argv, @stdin, @stdout, @stderr, @kernel).execute!
+          after_run
+
+          yield self if block_given?
+        end
+      end
+
+      def stop(reader)
+        @stopped     = true
+        @exit_status = @kernel.exitstatus
+      end
+
+      def stdin
+        @stdin.string
+      end
+
+      def stdout
+        @stdout.string
+      end
+
+      def stderr
+        @stderr.string
+      end
+
+      def write(input)
+        @stdin.write input
+      end
+
+      def close_io(name)
+        fail ArgumentError, 'Only stdin stdout and stderr are allowed to close' unless [:stdin, :stdout, :stderr].include? name
+
+        get_instance_variable(name.to_sym).close
+      end
+
+      def terminate
+        stop
+      end
+    end
+  end
+end

data/lib/aruba/processes/spawn_process.rb

@@ -0,0 +1,159 @@
+require 'childprocess'
+require 'tempfile'
+require 'shellwords'
+require 'aruba/errors'
+require 'aruba/processes/basic_process'
+
+module Aruba
+  module Processes
+    class SpawnProcess < BasicProcess
+      attr_reader :exit_status
+
+      # Create process
+      #
+      # @params [String] cmd
+      #   Command string
+      #
+      # @params [Integer] exit_timeout
+      #   The timeout until we expect the command to be finished
+      #
+      # @params [Integer] io_wait
+      #   The timeout until we expect the io to be finished
+      #
+      # @params [String] working_directory
+      #   The directory where the command will be executed
+      def initialize(cmd, exit_timeout, io_wait, working_directory)
+        @exit_timeout = exit_timeout
+        @io_wait      = io_wait
+
+        @cmd               = cmd
+        @process           = nil
+        @exit_status         = nil
+        @output_cache      = nil
+        @error_cache       = nil
+
+        super
+      end
+
+      # Return command line
+      def commandline
+        @cmd
+      end
+
+      # Run the command
+      #
+      # @yield [SpawnProcess]
+      #   Run code for process which was started
+      def run!
+        @process   = ChildProcess.build(*Shellwords.split(@cmd))
+        @out       = Tempfile.new("aruba-out")
+        @err       = Tempfile.new("aruba-err")
+        @exit_status = nil
+        @duplex    = true
+
+        before_run
+
+        @process.io.stdout = @out
+        @process.io.stderr = @err
+        @process.duplex    = @duplex
+        @process.cwd       = @working_directory
+
+        begin
+          @process.start
+        rescue ChildProcess::LaunchError => e
+          raise LaunchError, e.message
+        end
+
+        after_run
+
+        yield self if block_given?
+      end
+
+      def stdin
+        @process.io.stdin
+      end
+
+      def stdout
+        wait_for_io do
+          @process.io.stdout.flush
+          read(@out)
+        end || @output_cache
+      end
+
+      def stderr
+        wait_for_io do
+          @process.io.stderr.flush
+          read(@err)
+        end || @error_cache
+      end
+
+      def read_stdout
+        warn('The use of "#read_stdout" is deprecated. Use "#stdout" instead.')
+        stdout
+      end
+
+      def write(input)
+        @process.io.stdin.write(input)
+        @process.io.stdin.flush
+      end
+
+      def close_io(name)
+        @process.io.public_send(name.to_sym).close
+      end
+
+      def stop(reader)
+        @stopped = true
+
+        return @exit_status unless @process
+
+        @process.poll_for_exit(@exit_timeout) unless @process.exited?
+
+        @exit_status = @process.exit_code
+        @process   = nil
+
+        close_and_cache_out
+        close_and_cache_err
+
+        if reader
+          reader.stdout stdout
+          reader.stderr stderr
+        end
+
+        @exit_status
+      end
+
+      def terminate
+        return unless @process
+
+        @process.stop
+        stop nil
+      end
+
+      private
+
+      def wait_for_io(&block)
+        return unless @process
+
+        sleep @io_wait
+        yield
+      end
+
+      def read(io)
+        io.rewind
+        io.read
+      end
+
+      def close_and_cache_out
+        @output_cache = read @out
+        @out.close
+        @out = nil
+      end
+
+      def close_and_cache_err
+        @error_cache = read @err
+        @err.close
+        @err = nil
+      end
+    end
+  end
+end

data/lib/aruba/reporting.rb

@@ -19,7 +19,7 @@ if(ENV['ARUBA_REPORT_DIR'])
       end
 
       def pygmentize(file)
-        pygmentize = SpawnProcess.new(%{pygmentize -f html -O encoding=utf-8 "#{file}"}, 3, 0.5)
+        pygmentize = Processes::SpawnProcess.new(%{pygmentize -f html -O encoding=utf-8 "#{file}"}, 3, 0.5, Dir.getwd)
         pygmentize.run! do |p|
           exit_status = p.stop(false)
           if(exit_status == 0)
@@ -64,7 +64,7 @@ if(ENV['ARUBA_REPORT_DIR'])
 
       def files
         erb = ERB.new(template('files.erb'), nil, '-')
-        file = current_dir
+        file = current_directory
         erb.result(binding)
       end
 

data/lib/aruba/rspec.rb

@@ -0,0 +1,26 @@
+require 'rspec/core'
+require 'aruba/api'
+require 'aruba/reporting'
+
+RSpec.configure do |config|
+  config.include Aruba::Api, type: :aruba
+
+  config.before :each do
+    next unless self.class.include?(Aruba::Api)
+
+    restore_env
+    clean_current_directory
+  end
+
+  # config.before do
+  #   next unless self.class.include?(Aruba::Api)
+
+  #   current_example = context.example
+
+  #   announcer.activate(:environment) if current_example.metadata[:announce_env]
+  #   announcer.activate(:command)     if current_example.metadata[:announce_cmd]
+  #   announcer.activate(:directory)     if current_example.metadata[:announce_dir]
+  #   announcer.activate(:stdout)      if current_example.metadata[:announce_stdout]
+  #   announcer.activate(:stderr)      if current_example.metadata[:announce_stderr]
+  # end
+end

data/lib/aruba/spawn_process.rb

@@ -1,110 +1,11 @@
-require 'childprocess'
-require 'tempfile'
-require 'shellwords'
-require 'aruba/errors'
+require 'aruba/processes/spawn_process'
 
 module Aruba
-  class SpawnProcess
-    include Shellwords
+  class SpawnProcess < Aruba::Processes::SpawnProcess
+    def initialize(*args)
+      warn('The use of "Aruba::SpawnProcess" is deprecated. Use "Aruba::Processes::SpawnProcess" instead.')
 
-    def initialize(cmd, exit_timeout, io_wait)
-      @exit_timeout = exit_timeout
-      @io_wait = io_wait
-
-      @cmd = cmd
-      @process = nil
-      @exit_code = nil
-      @output_cache = nil
-      @error_cache = nil
-    end
-
-    def run!(&block)
-      @process = ChildProcess.build(*shellwords(@cmd))
-      @out = Tempfile.new("aruba-out")
-      @err = Tempfile.new("aruba-err")
-      @process.io.stdout = @out
-      @process.io.stderr = @err
-      @process.duplex = true
-      @exit_code = nil
-      begin
-        @process.start
-      rescue ChildProcess::LaunchError => e
-        raise LaunchError.new(e.message)
-      end
-      yield self if block_given?
-    end
-
-    def stdin
-      @process.io.stdin
-    end
-
-    def output
-      stdout + stderr
+      super
     end
-
-    def stdout
-      wait_for_io { read(@out) } || @output_cache
-    end
-
-    def stderr
-      wait_for_io { read(@err) } || @error_cache
-    end
-
-    def read_stdout
-      wait_for_io do
-        @process.io.stdout.flush
-        open(@out.path).read
-      end
-    end
-
-    def stop(reader)
-      return @exit_code unless @process
-      unless @process.exited?
-        @process.poll_for_exit(@exit_timeout)
-      end
-      @exit_code = @process.exit_code
-      @process = nil
-      close_and_cache_out
-      close_and_cache_err
-      if reader
-        reader.stdout stdout
-        reader.stderr stderr
-      end
-      @exit_code
-    end
-
-    def terminate
-      if @process
-        @process.stop
-        stop nil
-      end
-    end
-
-    private
-
-    def wait_for_io(&block)
-      if @process
-        sleep @io_wait
-        yield
-      end
-    end
-
-    def read(io)
-      io.rewind
-      io.read
-    end
-
-    def close_and_cache_out
-      @output_cache = read @out
-      @out.close
-      @out = nil
-    end
-
-    def close_and_cache_err
-      @error_cache = read @err
-      @err.close
-      @err = nil
-    end
-
   end
 end