aruba-win-fix 0.14.2

data/lib/aruba/platforms/unix_which.rb

@@ -0,0 +1,85 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Implement `which(command)` for UNIX/Linux
+    #
+    # @private
+    class UnixWhich
+      # Bail out because this should never be reached
+      class DefaultWhich
+        def self.match?(*)
+          true
+        end
+
+        def call(program, path)
+          fail %(Invalid input program "#{program}" and/or path "#{path}".)
+        end
+      end
+
+      # Find path for absolute or relative command
+      class AbsoluteOrRelativePathWhich
+        def self.match?(program)
+          Aruba.platform.absolute_path?(program) || Aruba.platform.relative_command?(program)
+        end
+
+        def call(program, path)
+          return File.expand_path(program) if Aruba.platform.executable?(program)
+
+          nil
+        end
+      end
+
+      # Find path for command
+      class ProgramWhich
+        def self.match?(program)
+          Aruba.platform.command?(program)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def call(program, path)
+          # 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
+
+            found = Dir[File.join(dir, program)].first
+            return found if found && Aruba.platform.executable?(found)
+          end
+
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      private
+
+      attr_reader :whiches
+
+      public
+
+      def initialize
+        @whiches = []
+        @whiches << AbsoluteOrRelativePathWhich
+        @whiches << ProgramWhich
+        @whiches << DefaultWhich
+      end
+
+      # Find fully quallified path for program
+      #
+      # @param [String] program
+      #   Name of program
+      #
+      # @param [String] path
+      #   ENV['PATH']
+      def call(program, path = ENV['PATH'])
+        raise ArgumentError, "ENV['PATH'] cannot be empty" if path.nil? || path.empty?
+        program = program.to_s
+
+        whiches.find { |w| w.match? program }.new.call(program, path)
+      end
+    end
+  end
+end

data/lib/aruba/platforms/windows_command_string.rb

@@ -0,0 +1,31 @@
+require 'delegate'
+
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # This is a command which should be run
+    #
+    # This adds `cmd.exec` in front of commmand
+    #
+    # @private
+    class WindowsCommandString < SimpleDelegator
+      def initialize(cmd)
+        __setobj__ format('%s /c "%s"', Aruba.platform.which('cmd.exe'), cmd)
+      end
+
+      # Convert to array
+      def to_a
+        Shellwords.split( __getobj__.gsub('\\', 'ARUBA_TMP_PATHSEPARATOR') ).
+          map { |w| w.gsub('ARUBA_TMP_PATHSEPARATOR', '\\') }
+      end
+
+      if RUBY_VERSION < '1.9'
+        def to_s
+          __getobj__.to_s
+        end
+        alias inspect to_s
+      end
+    end
+  end
+end

data/lib/aruba/platforms/windows_environment_variables.rb

@@ -0,0 +1,89 @@
+require 'aruba/platforms/unix_environment_variables'
+
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Windows is case-insensitive when it accesses its environment variables.
+    # That means that at the Windows command line:
+    #
+    #  C:>set Path
+    #  C:>Path=.;.\bin;c:\rubys\ruby-2.1.6-p336\bin;
+    #  C:>set PATH
+    #  C:>Path=.;.\bin;c:\rubys\ruby-2.1.6-p336\bin;
+    #
+    # If you access environment variables through ENV, you can access values no
+    # matter the case of the key:
+    #
+    #  irb: > ENV["Path"]
+    #  => ".;.\bin;c:\rubys\ruby-2.1.6-p336\bin;"
+    #  irb: > ENV["Path"]
+    #  => ".;.\bin;c:\rubys\ruby-2.1.6-p336\bin;"
+    #
+    # But if you copy the ENV to a hash, Ruby treats the keys as case sensitive:
+    #
+    #  irb: > env_copy = ENV.to_hash
+    #  => {"ALLUSERSPROFILE"=>"C:\\ProgramData", "ANSICON"=>"119x1000 (119x58)", "ANSICON_DEF"=>"7",  APPDATA"=>"C:\\Users\\blorf\\AppData\\Roaming", ....}
+    #  irb: > env["Path"]
+    #  => ".;.\bin;c:\rubys\ruby-2.1.6-p336\bin;"
+    #  irb: > env["PATH"]
+    #  => nil
+    #
+    # Thus we turn all of the environment variable keys to upper case so that
+    # aruba is ensured that accessing environment variables with upper case keys
+    # will always work.
+    class WindowsEnvironmentVariables < UnixEnvironmentVariables
+      def initialize(env = ENV.to_hash)
+        @actions = []
+
+        @env = if RUBY_VERSION <= '1.9.3'
+                 # rubocop:disable Style/EachWithObject
+                 env.inject({}) { |a, (k,v)| a[k.to_s.upcase] = v; a }
+               # rubocop:enable Style/EachWithObject
+               else
+                 env.each_with_object({}) { |(k,v), a| a[k.to_s.upcase] = v }
+               end
+      end
+
+      def update(other_env, &block)
+        other_env = if RUBY_VERSION <= '1.9.3'
+                      # rubocop:disable Style/EachWithObject
+                      other_env.inject({}) { |a, (k,v)| a[k.to_s.upcase] = v; a }
+                    # rubocop:enable Style/EachWithObject
+                    else
+                      other_env.each_with_object({}) { |(k,v), a| a[k.to_s.upcase] = v }
+                    end
+
+        super(other_env, &block)
+      end
+
+      def fetch(name, default = UnixEnvironmentVariables::UNDEFINED)
+        super(name.upcase, default)
+      end
+
+      def key?(name)
+        super(name.upcase)
+      end
+
+      def [](name)
+        super(name.upcase)
+      end
+
+      def []=(name, value)
+        super(name.upcase, value)
+      end
+
+      def append(name, value)
+        super(name.upcase, value)
+      end
+
+      def prepend(name, value)
+        super(name.upcase, value)
+      end
+
+      def delete(name, value)
+        super(name.upcase, value)
+      end
+    end
+  end
+end

data/lib/aruba/platforms/windows_platform.rb

@@ -0,0 +1,42 @@
+require 'ffi'
+
+require 'aruba/platforms/unix_platform'
+require 'aruba/platforms/windows_command_string'
+require 'aruba/platforms/windows_environment_variables'
+require 'aruba/platforms/windows_which'
+
+# Aruba
+module Aruba
+  # This abstracts OS-specific things
+  module Platforms
+    # 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.
+    #
+    # This includes all methods for the Windows platform
+    #
+    # @private
+    class WindowsPlatform < UnixPlatform
+      def self.match?
+        FFI::Platform.windows?
+      end
+
+      # @see UnixPlatform#command_string
+      def command_string
+        WindowsCommandString
+      end
+
+      # @see UnixPlatform#environment_variables
+      def environment_variables
+        WindowsEnvironmentVariables
+      end
+
+      # @see UnixPlatform#which
+      def which(program, path = ENV['PATH'])
+        WindowsWhich.new.call(program, path)
+      end
+    end
+  end
+end

data/lib/aruba/platforms/windows_which.rb

@@ -0,0 +1,106 @@
+# Aruba
+module Aruba
+  # Platforms
+  module Platforms
+    # Implement `which(command)` for windows
+    #
+    # @private
+    class WindowsWhich
+      # Bail out because this should never be reached
+      class DefaultWhich
+        def self.match?(*)
+          true
+        end
+
+        def call(program, path)
+          fail %(Invalid input program "#{program}" and/or path "#{path}".)
+        end
+      end
+
+      # Find path for absolute or relative command
+      class AbsoluteOrRelativePathWhich
+        def self.match?(program)
+          Aruba.platform.absolute_path?(program) || Aruba.platform.relative_command?(program)
+        end
+
+        def call(program, path)
+          # Expand `#path_exts`
+          found = Dir[program].first
+
+          return File.expand_path(found) if found && Aruba.platform.executable?(found)
+          nil
+        end
+      end
+
+      # Find path for command
+      class ProgramWhich
+        def self.match?(program)
+          Aruba.platform.command?(program)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/MethodLength
+        def call(program, path)
+          # 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.
+            file = file.tr("\\", "/")
+
+            found = Dir[file].first
+
+            # Convert all forward slashes to backslashes if supported
+            if found && Aruba.platform.executable?(found)
+              found.tr!(File::SEPARATOR, File::ALT_SEPARATOR)
+              return found
+            end
+          end
+
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      private
+
+      attr_reader :whiches
+
+      public
+
+      def initialize
+        @whiches = []
+        @whiches << AbsoluteOrRelativePathWhich
+        @whiches << ProgramWhich
+        @whiches << DefaultWhich
+      end
+
+      # Find fully quallified path for program
+      #
+      # @param [String] program
+      #   Name of program
+      #
+      # @param [String] path
+      #   ENV['PATH']
+      def call(program, path = ENV['PATH'])
+        raise ArgumentError, "ENV['PATH'] cannot be empty" if path.nil? || path.empty?
+
+        program = program.to_s
+        program += windows_executable_extentions if File.extname(program).empty?
+
+        whiches.find { |w| w.match? program }.new.call(program, path)
+      end
+
+      private
+
+      def windows_executable_extentions
+        ENV['PATHEXT'] ? format('.{%s}', ENV['PATHEXT'].tr(';', ',').tr('.','')).downcase : '.{exe,com,bat}'
+      end
+    end
+  end
+end

data/lib/aruba/processes/basic_process.rb

@@ -0,0 +1,143 @@
+require 'aruba/platform'
+require 'shellwords'
+
+# Aruba
+module Aruba
+  # Processes
+  module Processes
+    # Basic Process
+    #
+    # `BasicProcess` is not meant for direct use - `BasicProcess.new` - by users.
+    #
+    # @private
+    class BasicProcess
+      attr_reader :exit_status, :environment, :working_directory, :main_class, :io_wait_timeout, :exit_timeout, :startup_wait_time
+
+      def initialize(cmd, exit_timeout, io_wait_timeout, working_directory, environment = ENV.to_hash.dup, main_class = nil, stop_signal = nil, startup_wait_time = 0)
+        @cmd               = cmd
+        @working_directory = working_directory
+        @environment       = environment
+        @main_class        = main_class
+        @exit_status       = nil
+        @stop_signal       = stop_signal
+        @startup_wait_time = startup_wait_time
+
+        @exit_timeout    = exit_timeout
+        @io_wait_timeout = io_wait_timeout
+
+        @started         = false
+      end
+
+      # Return command line
+      def commandline
+        @cmd
+      end
+
+      # Output pid of process
+      def pid
+        'No implemented'
+      end
+
+      # Output stderr and stdout
+      def output(opts = {})
+        stdout(opts) + stderr(opts)
+      end
+
+      def write(*)
+        NotImplementedError
+      end
+
+      def stdin(*)
+        NotImplementedError
+      end
+
+      def stdout(*)
+        NotImplementedError
+      end
+
+      def stderr(*)
+        NotImplementedError
+      end
+
+      def close_io(*)
+        NotImplementedError
+      end
+
+      def send_signal(*)
+        NotImplementedError
+      end
+
+      def filesystem_status
+        NotImplementedError
+      end
+
+      def content
+        NotImplementedError
+      end
+
+      def wait
+        NotImplementedError
+      end
+
+      # Restart a command
+      def restart
+        stop
+        start
+      end
+
+      # Was process already stopped
+      def stopped?
+        @started == false
+      end
+
+      # Was process already started
+      def started?
+        @started == true
+      end
+
+      # Does the process failed to stop in time
+      def timed_out?
+        @timed_out == true
+      end
+
+      # @deprecated
+      # @private
+      def run!
+        Aruba.platform.deprecated('The use of "command#run!" is deprecated. You can simply use "command#start" instead.')
+
+        start
+      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
+
+      def inspect
+        out = stdout(:wait_for_io => 0) + stderr(:wait_for_io => 0)
+
+        out = if out.length > 76
+                out[0, 75] + ' ...'
+              else
+                out
+              end
+
+        format '#<%s:%s commandline="%s": output="%s">', self.class, self.object_id, commandline, out
+      end
+      alias to_s inspect
+
+      private
+
+      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