aruba 0.8.1 → 0.9.0.pre

data/lib/aruba/platforms/windows_command_string.rb

@@ -0,0 +1,23 @@
+require 'delegate'
+
+module Aruba
+  module Platforms
+    # This is a command which should be run
+    class WindowsCommandString < SimpleDelegator
+      def initialize(cmd)
+        __setobj__ format('%s /c "%s"', Aruba.platform.which('cmd.exe'), cmd)
+      end
+
+      def to_a
+        Shellwords.split __getobj__
+      end
+
+      if RUBY_VERSION < '1.9'
+        def to_s
+          __getobj__.to_s
+        end
+        alias_method :inspect, :to_s
+      end
+    end
+  end
+end

data/lib/aruba/platforms/windows_environment_variables.rb

@@ -0,0 +1,83 @@
+require 'aruba/platforms/unix_environment_variables'
+
+module Aruba
+  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)
+        @env = Marshal.load(Marshal.dump(env))
+
+        if RUBY_VERSION <= '1.9.3'
+          # rubocop:disable Style/EachWithObject
+          @env = @env.inject({}) { |a, (k,v)| a[k.to_s.upcase] = v; a }
+          # rubocop:enable Style/EachWithObject
+        else
+          @env = @env.each_with_object({}) { |(k,v), a| a[k.to_s.upcase] = v }
+        end
+      end
+
+      def update(other_env, &block)
+        if RUBY_VERSION <= '1.9.3'
+          # rubocop:disable Style/EachWithObject
+          other_env = other_env.inject({}) { |a, (k,v)| a[k.to_s.upcase] = v; a }
+          # rubocop:enable Style/EachWithObject
+        else
+          other_env = 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
+    end
+  end
+end

data/lib/aruba/platforms/windows_platform.rb

@@ -0,0 +1,39 @@
+require 'ffi'
+
+require 'aruba/platforms/unix_platform'
+require 'aruba/platforms/windows_command_string'
+require 'aruba/platforms/windows_environment_variables'
+require 'aruba/platforms/windows_which'
+
+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
+    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.new
+      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,104 @@
+require 'aruba/platform'
+
+module Aruba
+  module Platforms
+    # Implement `which(command)` for windows
+    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_file?(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_file?(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/process_monitor.rb

@@ -60,7 +60,7 @@ module Aruba
     # @param [String] cmd
     #   The command
     def output_from(cmd)
-      cmd = Platform.detect_ruby(cmd)
+      cmd = Aruba.platform.detect_ruby(cmd)
       get_process(cmd).output
     end
 
@@ -69,7 +69,7 @@ module Aruba
     # @param [String] cmd
     #   The command
     def stdout_from(cmd)
-      cmd = Platform.detect_ruby(cmd)
+      cmd = Aruba.platform.detect_ruby(cmd)
       get_process(cmd).stdout
     end
 
@@ -78,7 +78,7 @@ module Aruba
     # @param [String] cmd
     #   The command
     def stderr_from(cmd)
-      cmd = Platform.detect_ruby(cmd)
+      cmd = Aruba.platform.detect_ruby(cmd)
       get_process(cmd).stderr
     end
 

data/lib/aruba/processes/basic_process.rb

@@ -6,7 +6,7 @@ module Aruba
     class BasicProcess
       attr_reader :exit_status, :environment
 
-      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash, main_class = nil)
+      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash.dup, main_class = nil)
         @cmd               = cmd
         @working_directory = working_directory
         @environment       = environment
@@ -24,6 +24,26 @@ module Aruba
         stdout + stderr
       end
 
+      def write(*)
+        NotImplementedError
+      end
+
+      def stdin(*)
+        NotImplementedError
+      end
+
+      def stdout(*)
+        NotImplementedError
+      end
+
+      def stderr(*)
+        NotImplementedError
+      end
+
+      def close_io(*)
+        NotImplementedError
+      end
+
       # Was process already stopped
       def stopped?
         @stopped == true
@@ -42,8 +62,8 @@ module Aruba
 
       private
 
-      def which(program, path = environment['PATH'])
-        Aruba::Platform.which(program, path)
+      def which(program)
+        Aruba.platform.which(program, environment['PATH'])
       end
 
       def command

data/lib/aruba/processes/debug_process.rb

@@ -13,12 +13,12 @@ module Aruba
       # 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'])
+        fail LaunchError, %(Command "#{command}" not found in PATH-variable "#{environment['PATH']}".) unless which(command)
         # rubocop:enable  Metrics/LineLength
 
         if RUBY_VERSION < '1.9'
           begin
-            old_env = ENV.to_hash
+            old_env = ENV.to_hash.dup
             ENV.update environment
 
             Dir.chdir @working_directory do

data/lib/aruba/processes/in_process.rb

@@ -31,7 +31,7 @@ module Aruba
 
       attr_reader :main_class
 
-      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash, main_class = nil)
+      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash.dup, main_class = nil)
         @cmd               = cmd
         @argv              = arguments
         @stdin             = StringIO.new

data/lib/aruba/processes/spawn_process.rb

@@ -1,8 +1,10 @@
 require 'childprocess'
 require 'tempfile'
 require 'shellwords'
+
 require 'aruba/errors'
 require 'aruba/processes/basic_process'
+require 'aruba/platform'
 
 module Aruba
   module Processes
@@ -25,7 +27,7 @@ module Aruba
       #
       # @params [String] working_directory
       #   The directory where the command will be executed
-      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash, main_class = nil)
+      def initialize(cmd, exit_timeout, io_wait, working_directory, environment = ENV.to_hash.dup, main_class = nil)
         super
 
         @exit_timeout = exit_timeout
@@ -43,11 +45,15 @@ module Aruba
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Metrics/CyclomaticComplexity
       def run!
+        # gather fully qualified path
+        cmd = which(command)
         # rubocop:disable  Metrics/LineLength
-        fail LaunchError, %(Command "#{command}" not found in PATH-variable "#{environment['PATH']}".) unless which(command, environment['PATH'])
+        fail LaunchError, %(Command "#{command}" not found in PATH-variable "#{environment['PATH']}".) if cmd.nil?
         # rubocop:enable  Metrics/LineLength
 
-        @process   = ChildProcess.build(which(command, environment['PATH']), *arguments)
+        cmd = Aruba.platform.command_string.new(cmd)
+
+        @process   = ChildProcess.build(*[cmd.to_a, arguments].flatten)
         @out       = Tempfile.new("aruba-out")
         @err       = Tempfile.new("aruba-err")
         @exit_status = nil
@@ -65,7 +71,7 @@ module Aruba
         begin
           @process.start
         rescue ChildProcess::LaunchError => e
-          raise LaunchError, e.message
+          raise LaunchError, "It tried to start #{cmd}. " + e.message
         end
 
         after_run

data/lib/aruba/reporting.rb

@@ -50,7 +50,7 @@ if(ENV['ARUBA_REPORT_DIR'])
       end
 
       def output
-        @aruba_keep_ansi = true # We want the output coloured!
+        aruba.config.keep_ansi = true # We want the output coloured!
         escaped_stdout = CGI.escapeHTML(all_stdout)
         html = Bcat::ANSI.new(escaped_stdout).to_html
         Bcat::ANSI::STYLES.each do |name, style|

data/lib/aruba/rspec.rb

@@ -14,17 +14,19 @@ RSpec.configure do |config|
   config.include Aruba::Api, :type => :aruba
 
   # Setup environment for aruba
-  config.before :each do
-    next unless self.class.include? Aruba::Api
+  config.around :each do |example|
+    if self.class.include? Aruba::Api
+      restore_env
+      setup_aruba
+    end
 
-    restore_env
-    setup_aruba
+    example.run
   end
 
   if Aruba::VERSION >= '1.0.0'
     config.around :each do |example|
       begin
-        old_env = ENV.to_hash
+        old_env = ENV.to_hash.dup
         example.run
       ensure
         ENV.clear
@@ -45,7 +47,7 @@ RSpec.configure do |config|
     next unless self.class.include?(Aruba::Api)
 
     if example.metadata[:announce_environment]
-      Aruba::Platform.deprecated 'announce_environment is deprecated. Use announce_modified_environment instead'
+      Aruba.platform.deprecated 'announce_environment is deprecated. Use announce_modified_environment instead'
 
       announcer.activate(:modified_environment)
     end

data/lib/aruba/runtime.rb

@@ -1,15 +1,18 @@
 require 'aruba/config'
-require 'aruba/environment'
+require 'aruba/aruba_logger'
 
 module Aruba
   class Runtime
-    attr_reader :config, :current_directory, :environment, :root_directory
+    attr_reader :config, :current_directory, :environment, :root_directory, :logger
 
     def initialize
       @config            = Aruba.config.make_copy
       @current_directory = ArubaPath.new(@config.working_directory)
       @root_directory    = ArubaPath.new(@config.root_directory)
-      @environment       = Environment.new
+      @environment       = Aruba.platform.environment_variables
+
+      @logger      = ArubaLogger.new
+      @logger.mode = @config.log_level
     end
 
     # The path to the directory which contains fixtures
@@ -20,12 +23,12 @@ module Aruba
     def fixtures_directory
       unless @fixtures_directory
         candidates = config.fixtures_directories.map { |dir| File.join(root_directory, dir) }
-        @fixtures_directory = candidates.find { |d| Aruba::Platform.directory? d }
+        @fixtures_directory = candidates.find { |d| Aruba.platform.directory? d }
 
         fail "No existing fixtures directory found in #{candidates.map { |d| format('"%s"', d) }.join(', ')}. " unless @fixtures_directory
       end
 
-      fail %(Fixtures directory "#{@fixtures_directory}" is not a directory) unless Aruba::Platform.directory?(@fixtures_directory)
+      fail %(Fixtures directory "#{@fixtures_directory}" is not a directory) unless Aruba.platform.directory?(@fixtures_directory)
 
       ArubaPath.new(@fixtures_directory)
     end