aruba 0.7.4 → 0.8.0.pre

data/lib/aruba/platform.rb

@@ -0,0 +1,230 @@
+require 'rbconfig'
+require 'pathname'
+
+module Aruba
+  # WARNING:
+  # All methods found here are not considered part of the public API of aruba.
+  #
+  # Those methods can be changed at any time in the feature or removed without
+  # any further notice.
+  module Platform
+    def detect_ruby(cmd)
+      if cmd =~ /^ruby\s/
+        cmd.gsub(/^ruby\s/, "#{current_ruby} ")
+      else
+        cmd
+      end
+    end
+
+    def deprecated(msg)
+      warn(format('%s. Called by %s', msg, caller[1]))
+    end
+
+    def current_ruby
+      ::File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    end
+
+    # @deprecated
+    # Add newline at the end
+    def ensure_newline(str)
+      deprecated('The use of "#ensure_newline" is deprecated. It will be removed soon')
+
+      str.chomp << "\n"
+    end
+
+    def require_matching_files(pattern, base)
+      if RUBY_VERSION < '1.9.'
+        ::Dir.glob(::File.expand_path(pattern, base)).each { |f| require File.join(File.dirname(f), File.basename(f, '.rb')) }
+      else
+        ::Dir.glob(::File.expand_path(pattern, base)).each { |f| require_relative f }
+      end
+    end
+
+    # Create directory and subdirectories
+    def mkdir(dir_name)
+      dir_name = ::File.expand_path(dir_name)
+
+      ::FileUtils.mkdir_p(dir_name) unless ::File.directory?(dir_name)
+    end
+
+    # Remove file, directory + sub-directories
+    def rm(paths, options = {})
+      paths = Array(paths).map { |p| ::File.expand_path(p) }
+
+      FileUtils.rm_r(paths, options)
+    end
+
+    # Change to directory
+    def chdir(dir_name, &block)
+      dir_name = ::File.expand_path(dir_name.to_s)
+
+      ::Dir.chdir(dir_name, &block)
+    end
+
+    # Touch file, directory
+    def touch(args, options)
+      FileUtils.touch(args, options)
+    end
+
+    # Copy file/directory
+    def cp(args, options)
+      FileUtils.cp_r(args, options)
+    end
+
+    # Change mode of file/directory
+    def chmod(mode, args, options)
+      FileUtils.chmod_R(mode, args, options)
+    end
+
+    # Exists and is file
+    def file?(f)
+      File.file? f
+    end
+
+    # Exists and is directory
+    def directory?(f)
+      File.directory? f
+    end
+
+    # Path Exists
+    def exist?(f)
+      File.exist? f
+    end
+
+    # Path is executable
+    def executable_file?(f)
+      File.file?(f) && File.executable?(f)
+    end
+
+    # Expand path
+    def expand_path(path, base)
+      File.expand_path(path, base)
+    end
+
+    def absolute_path?(path)
+      Pathname.new(path).absolute?
+    end
+
+    # Check if command is relative
+    #
+    # @return [TrueClass, FalseClass]
+    #   true
+    #     * bin/command.sh
+    #
+    #   false
+    #     * /bin/command.sh
+    #     * command.sh
+    def relative_command?(path)
+      p = Pathname.new(path)
+      p.relative? && p.basename != p
+    end
+
+    # Write to file
+    def write_file(path, content)
+      if RUBY_VERSION < '1.9'
+        File.open(path, 'wb') do |f|
+          f.print content
+        end
+      else
+        File.write(path, content)
+      end
+    end
+
+    # Unescape string
+    #
+    # @param [String] string
+    #   The string which should be unescaped, e.g. the output of a command
+    #
+    # @return
+    #   The string stripped from escape sequences
+    def unescape(string, keep_ansi = true)
+      string = string.gsub('\n', "\n").gsub('\"', '"').gsub('\e', "\e")
+      string = string.gsub(/\e\[\d+(?>(;\d+)*)m/, '') unless keep_ansi
+      string
+    end
+
+    # Resolve path for command using the PATH-environment variable
+    #
+    # Mostly taken from here: https://github.com/djberg96/ptools
+    #
+    # @param [#to_s] program
+    #   The name of the program which should be resolved
+    #
+    # @param [String] path
+    #   The PATH, a string concatenated with ":", e.g. /usr/bin/:/bin on a
+    #   UNIX-system
+    #
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def which(program, path = ENV['PATH'])
+      on_windows = false
+      on_windows = true if File::ALT_SEPARATOR
+
+      program = program.to_s
+
+      path_exts = ENV['PATHEXT'] ? ('.{' + ENV['PATHEXT'].tr(';', ',').tr('.','') + '}').downcase : '.{exe,com,bat}' if on_windows
+
+      raise ArgumentError, "ENV['PATH'] cannot be empty" if path.nil? || path.empty?
+
+      # Bail out early if an absolute path is provided or the command path is relative
+      # Examples: /usr/bin/command or bin/command.sh
+      if Aruba::Platform.absolute_path?(program) || Aruba::Platform.relative_command?(program)
+        program += path_exts if on_windows && File.extname(program).empty?
+
+        found = Dir[program].first
+
+        return File.expand_path(found) if found && Aruba::Platform.executable_file?(found)
+        return nil
+      end
+
+      # Iterate over each path glob the dir + program.
+      path.split(File::PATH_SEPARATOR).each do |dir|
+        dir = Aruba::Platform.expand_path(dir, Dir.getwd)
+
+        next unless Aruba::Platform.exist?(dir) # In case of bogus second argument
+        file = File.join(dir, program)
+
+        # Dir[] doesn't handle backslashes properly, so convert them. Also, if
+        # the program name doesn't have an extension, try them all.
+        if on_windows
+          file = file.tr("\\", "/")
+          file += path_exts if File.extname(program).empty?
+        end
+
+        found = Dir[file].first
+
+        # Convert all forward slashes to backslashes if supported
+        if found && Aruba::Platform.executable_file?(found)
+          found.tr!(File::SEPARATOR, File::ALT_SEPARATOR) if on_windows
+          return found
+        end
+      end
+
+      nil
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    module_function :detect_ruby, \
+      :current_ruby, \
+      :ensure_newline, \
+      :require_matching_files, \
+      :mkdir, \
+      :rm, \
+      :chdir, \
+      :deprecated, \
+      :touch, \
+      :cp, \
+      :chmod, \
+      :file?, \
+      :directory?, \
+      :exist?, \
+      :expand_path, \
+      :absolute_path?, \
+      :relative_command?, \
+      :executable_file?, \
+      :unescape, \
+      :which, \
+      :write_file
+  end
+end

data/lib/aruba/process_monitor.rb

@@ -41,6 +41,8 @@ module Aruba
 
     def register_process(name, process)
       processes << [name, process]
+
+      [name, process]
     end
 
     def get_process(wanted)
@@ -58,7 +60,7 @@ module Aruba
     # @param [String] cmd
     #   The command
     def output_from(cmd)
-      cmd = Utils.detect_ruby(cmd)
+      cmd = Platform.detect_ruby(cmd)
       get_process(cmd).output
     end
 
@@ -67,7 +69,7 @@ module Aruba
     # @param [String] cmd
     #   The command
     def stdout_from(cmd)
-      cmd = Utils.detect_ruby(cmd)
+      cmd = Platform.detect_ruby(cmd)
       get_process(cmd).stdout
     end
 
@@ -76,7 +78,7 @@ module Aruba
     # @param [String] cmd
     #   The command
     def stderr_from(cmd)
-      cmd = Utils.detect_ruby(cmd)
+      cmd = Platform.detect_ruby(cmd)
       get_process(cmd).stderr
     end
 
@@ -86,7 +88,15 @@ module Aruba
     #   The stdout of all process which have run before
     def all_stdout
       stop_processes!
-      only_processes.each_with_object("") { |ps, out| out << ps.stdout }
+
+      if RUBY_VERSION < '1.9'
+        out = ''
+        only_processes.each { |ps| out << ps.stdout }
+
+        out
+      else
+        only_processes.each_with_object("") { |ps, o| o << ps.stdout }
+      end
     end
 
     # Get stderr of all processes
@@ -95,7 +105,15 @@ module Aruba
     #   The stderr of all process which have run before
     def all_stderr
       stop_processes!
-      only_processes.each_with_object("") { |ps, out| out << ps.stderr }
+
+      if RUBY_VERSION < '1.9'
+        out = ''
+        only_processes.each { |ps| out << ps.stderr }
+
+        out
+      else
+        only_processes.each_with_object("") { |ps, o| o << ps.stderr }
+      end
     end
 
     # Get stderr and stdout of all processes

data/lib/aruba/processes/basic_process.rb

@@ -1,8 +1,21 @@
+require 'aruba/platform'
+require 'shellwords'
+
 module Aruba
   module Processes
     class BasicProcess
-      def initialize(cmd, exit_timeout, io_wait, working_directory)
+      attr_reader :exit_status, :environment
+
+      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash)
+        @cmd               = cmd
         @working_directory = working_directory
+        @environment       = environment
+        @exit_status       = nil
+      end
+
+      # Return command line
+      def commandline
+        @cmd
       end
 
       # Output stderr and stdout
@@ -15,11 +28,32 @@ module Aruba
         @stopped == true
       end
 
+      # Does the process failed to stop in time
+      def timed_out?
+        @timed_out == 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
+
+      private
+
+      def which(program, path = environment['PATH'])
+        Aruba::Platform.which(program, path)
+      end
+
+      def command
+        Shellwords.split(commandline).first
+      end
+
+      def arguments
+        return Shellwords.split(commandline)[1..-1] if Shellwords.split(commandline).size > 1
+
+        []
+      end
     end
   end
 end

data/lib/aruba/processes/debug_process.rb

@@ -16,24 +16,35 @@ module Aruba
     # @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
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def run!
+        # rubocop:disable  Metrics/LineLength
+        fail LaunchError, %(Command "#{command}" not found in PATH-variable "#{environment['PATH']}".) unless which(command, environment['PATH'])
+        # rubocop:enable  Metrics/LineLength
 
-      # Return command line
-      def commandline
-        @cmd
-      end
+        if RUBY_VERSION < '1.9'
+          begin
+            old_env = ENV.to_hash
+            ENV.update environment
 
-      def run!
-        @exit_status = system(@cmd, chdir: @working_directory) ? 0 : 1
+            Dir.chdir @working_directory do
+              @exit_status = system(@cmd) ? 0 : 1
+            end
+          ensure
+            ENV.clear
+            ENV.update old_env
+          end
+        elsif RUBY_VERSION < '2'
+          Dir.chdir @working_directory do
+            @exit_status = system(environment, @cmd) ? 0 : 1
+          end
+        else
+          @exit_status = system(environment, @cmd, :chdir => @working_directory) ? 0 : 1
+        end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
 
       def stdin(*); end
 

data/lib/aruba/processes/in_process.rb

@@ -23,9 +23,9 @@ module Aruba
         attr_accessor :main_class
       end
 
-      def initialize(cmd, exit_timeout, io_wait, working_directory)
-        args               = Shellwords.split(cmd)
-        @argv              = args[1..-1]
+      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash)
+        @cmd               = cmd
+        @argv              = arguments
         @stdin             = StringIO.new
         @stdout            = StringIO.new
         @stderr            = StringIO.new
@@ -34,17 +34,16 @@ module Aruba
         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!
+
+          with_environment do
+            self.class.main_class.new(@argv, @stdin, @stdout, @stderr, @kernel).execute!
+          end
+
           after_run
 
           yield self if block_given?
@@ -81,6 +80,19 @@ module Aruba
       def terminate
         stop
       end
+
+      private
+
+      def with_environment(&block)
+        old_env = ENV.to_hash
+
+        ENV.update(environment)
+
+        block.call
+      ensure
+        ENV.clear
+        ENV.update old_env
+      end
     end
   end
 end