aruba 1.0.0.pre.alpha.2 → 1.0.1

data/lib/aruba/api/bundler.rb

@@ -0,0 +1,16 @@
+require 'aruba/api/environment'
+
+module Aruba
+  module Api
+    module Bundler
+      include Environment
+
+      # Unset variables used by bundler
+      def unset_bundler_env_vars
+        %w(RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE).each do |key|
+          delete_environment_variable(key)
+        end
+      end
+    end
+  end
+end

data/lib/aruba/api/commands.rb

@@ -0,0 +1,272 @@
+require 'pathname'
+
+require 'aruba/platform'
+require 'aruba/command'
+
+# require 'win32/file' if File::ALT_SEPARATOR
+
+# Aruba
+module Aruba
+  # Api
+  module Api
+    # Command module
+    module Commands
+      # Resolve path for command using the PATH-environment variable
+      #
+      # @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
+      def which(program, path = nil)
+        with_environment do
+          # ENV is set within this block
+          path = ENV['PATH'] if path.nil?
+
+          Aruba.platform.which(program, path)
+        end
+      end
+
+      # Pipe data in file
+      #
+      # @param [String] file_name
+      #   The file which should be used to pipe in data
+      def pipe_in_file(file_name)
+        file_name = expand_path(file_name)
+
+        File.open(file_name, 'r').each_line do |line|
+          last_command_started.write(line)
+        end
+      end
+
+      # Return all commands
+      #
+      # @return [Array]
+      #   List of commands
+      def all_commands
+        aruba.command_monitor.registered_commands
+      end
+
+      # Last command started
+      def last_command_started
+        aruba.command_monitor.last_command_started
+      end
+
+      # Last command stopped
+      def last_command_stopped
+        aruba.command_monitor.last_command_stopped
+      end
+
+      # Stop all commands
+      #
+      # @yield [Command]
+      #   If block is given use it to filter the commands which should be
+      #   stoppend.
+      def stop_all_commands(&block)
+        cmds = if block_given?
+                 all_commands.select(&block)
+               else
+                 all_commands
+               end
+
+        cmds.each(&:stop)
+
+        self
+      end
+
+      # Terminate all commands
+      #
+      # @yield [Command]
+      #   If block is given use it to filter the commands which should be
+      #   terminated.
+      def terminate_all_commands(&block)
+        cmds = if block_given?
+                 all_commands.select(&block)
+               else
+                 all_commands
+               end
+
+        cmds.each(&:terminate)
+
+        self
+      end
+
+      # Get stdout of all processes
+      #
+      # @return [String]
+      #   The stdout of all processes which have run before
+      def all_stdout
+        aruba.command_monitor.all_stdout
+      end
+
+      # Get stderr of all processes
+      #
+      # @return [String]
+      #   The stderr of all processes which have run before
+      def all_stderr
+        aruba.command_monitor.all_stderr
+      end
+
+      # Get stderr and stdout of all processes
+      #
+      # @return [String]
+      #   The stderr and stdout of all processes which have run before
+      def all_output
+        aruba.command_monitor.all_output
+      end
+
+      # Find a started command
+      #
+      # @param [String, Command] commandline
+      #   The commandline
+      def find_command(commandline)
+        aruba.command_monitor.find(commandline)
+      end
+
+      # Run given command and stop it if timeout is reached
+      #
+      # @param [String] cmd
+      #   The command which should be executed
+      #
+      # @param [Hash] opts
+      #   Options
+      #
+      # @option opts [Numeric] exit_timeout
+      #   If the timeout is reached the command will be killed
+      #
+      # @option opts [Numeric] io_wait_timeout
+      #   Wait for IO to finish
+      #
+      # @option opts [Numeric] startup_wait_time
+      #   Wait for a command to start
+      #
+      # @option opts [String] stop_signal
+      #   Use signal to stop command
+      #
+      # @yield [SpawnProcess]
+      #   Run block with process
+      #
+      def run_command(cmd, opts = {})
+        command = prepare_command(cmd, opts)
+
+        unless command.interactive?
+          raise NotImplementedError,
+                'Running interactively is not supported with this process launcher.'
+        end
+
+        start_command(command)
+
+        block_given? ? yield(command) : command
+      end
+
+      # Run a command with aruba
+      #
+      # Checks for error during command execution and checks the output to detect
+      # an timeout error.
+      #
+      # @param [String] cmd
+      #   The command to be executed
+      #
+      # @param [Hash] opts
+      #   Options for aruba
+      #
+      # @option opts [Boolean] :fail_on_error
+      #   Should aruba fail on error?
+      #
+      # @option opts [Numeric] :exit_timeout
+      #   Timeout for execution
+      #
+      # @option opts [Numeric] :io_wait_timeout
+      #   Timeout for IO - STDERR, STDOUT
+      #
+      def run_command_and_stop(cmd, opts = {})
+        fail_on_error = if opts.key?(:fail_on_error)
+                          opts.delete(:fail_on_error) == true
+                        else
+                          true
+                        end
+
+        command = prepare_command(cmd, opts)
+        start_command(command)
+        command.stop
+
+        return unless fail_on_error
+
+        begin
+          expect(command).to have_finished_in_time
+          expect(command).to be_successfully_executed
+        rescue ::RSpec::Expectations::ExpectationNotMetError => e
+          aruba.announcer.activate(aruba.config.activate_announcer_on_command_failure)
+          aruba.event_bus.notify Events::CommandStopped.new(command)
+          raise e
+        end
+      end
+
+      # Provide data to command via stdin
+      #
+      # @param [String] input
+      #   The input for the command
+      def type(input)
+        return close_input if input == "\u0004"
+
+        last_command_started.write(input << "\n")
+      end
+
+      # Close stdin
+      def close_input
+        last_command_started.close_io(:stdin)
+      end
+
+      private
+
+      def prepare_command(cmd, opts)
+        exit_timeout      = opts[:exit_timeout] || aruba.config.exit_timeout
+        io_wait_timeout   = opts[:io_wait_timeout] || aruba.config.io_wait_timeout
+        stop_signal       = opts[:stop_signal] || aruba.config.stop_signal
+        startup_wait_time = opts[:startup_wait_time] || aruba.config.startup_wait_time
+
+        cmd = replace_variables(cmd)
+
+        @commands ||= []
+        @commands << cmd
+
+        environment       = aruba.environment
+        working_directory = expand_path('.')
+        event_bus         = aruba.event_bus
+
+        cmd = Aruba.platform.detect_ruby(cmd)
+
+        mode = aruba.config.command_launcher
+
+        main_class = aruba.config.main_class
+
+        Command.new(
+          cmd,
+          mode: mode,
+          exit_timeout: exit_timeout,
+          io_wait_timeout: io_wait_timeout,
+          working_directory: working_directory,
+          environment: environment.to_hash,
+          main_class: main_class,
+          stop_signal: stop_signal,
+          startup_wait_time: startup_wait_time,
+          event_bus: event_bus
+        )
+      end
+
+      def start_command(command)
+        aruba.config.before(:command, self, command)
+
+        in_current_directory do
+          command.start
+        end
+
+        stop_signal = command.stop_signal
+        aruba.announcer.announce(:stop_signal, command.pid, stop_signal) if stop_signal
+
+        aruba.config.after(:command, self, command)
+      end
+    end
+  end
+end

data/lib/aruba/api/core.rb

@@ -3,8 +3,6 @@ require 'aruba/runtime'
 require 'aruba/errors'
 require 'aruba/setup'
 
-require 'aruba/config/jruby'
-
 # Aruba
 module Aruba
   # Api
@@ -17,6 +15,10 @@ module Aruba
 
       # Aruba Runtime
       def aruba
+        # TODO: Check this variable being accessed inconsistently. Should only
+        # be using the memo!
+        # Renaming this to `aruba` causes 100's of rspec failures. Needs a
+        # deeper dive, approach with caution!
         @_aruba_runtime ||= Runtime.new
       end
 
@@ -25,12 +27,21 @@ module Aruba
       # This will only clean up aruba's working directory to remove all
       # artifacts of your tests. This does NOT clean up the current working
       # directory.
-      def setup_aruba
-        Aruba::Setup.new(aruba).call
+      def setup_aruba(clobber = true)
+        Aruba::Setup.new(aruba).call(clobber)
 
         self
       end
 
+      # Execute block in Aruba's current directory
+      #
+      # @yield
+      #   The block which should be run in current directory
+      def in_current_directory(&block)
+        create_directory '.' unless directory?('.')
+        cd('.', &block)
+      end
+
       # Switch to directory
       #
       # @param [String] dir
@@ -45,25 +56,30 @@ module Aruba
       # @example Run code in directory
       #   result = cd('some-dir') { Dir.getwd }
       #
-      # rubocop:disable Metrics/MethodLength
       def cd(dir, &block)
         if block_given?
           begin
-            fail ArgumentError, "#{expand_path(dir)} is not a directory or does not exist." unless Aruba.platform.directory? expand_path(dir)
+            unless Aruba.platform.directory?(expand_path(dir))
+              raise ArgumentError,
+                    "#{expand_path(dir)} is not a directory or does not exist."
+            end
 
             old_directory = expand_path('.')
             aruba.current_directory << dir
             new_directory = expand_path('.')
 
-            aruba.event_bus.notify Events::ChangedWorkingDirectory.new(:old => old_directory, :new => new_directory)
+            aruba.event_bus.notify Events::ChangedWorkingDirectory.new(old: old_directory,
+                                                                       new: new_directory)
 
             old_dir = Aruba.platform.getwd
 
-            Aruba.platform.chdir File.join(aruba.root_directory, aruba.current_directory)
+            real_new_directory = File.expand_path(aruba.current_directory,
+                                                  aruba.root_directory)
+            Aruba.platform.chdir real_new_directory
 
             result = with_environment(
               'OLDPWD' => old_dir,
-              'PWD' => File.expand_path(File.join(aruba.root_directory, aruba.current_directory)),
+              'PWD' => real_new_directory,
               &block
             )
           ensure
@@ -74,17 +90,19 @@ module Aruba
           return result
         end
 
-        fail ArgumentError, "#{expand_path(dir)} is not a directory or does not exist." unless Aruba.platform.directory? expand_path(dir)
+        unless Aruba.platform.directory?(expand_path(dir))
+          raise ArgumentError, "#{expand_path(dir)} is not a directory or does not exist."
+        end
 
         old_directory = expand_path('.')
         aruba.current_directory << dir
         new_directory = expand_path('.')
 
-        aruba.event_bus.notify Events::ChangedWorkingDirectory.new(:old => old_directory, :new => new_directory)
+        aruba.event_bus.notify Events::ChangedWorkingDirectory.new(old: old_directory,
+                                                                   new: new_directory)
 
         self
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Expand file name
       #
@@ -117,48 +135,73 @@ module Aruba
       #   # => <path>/test/fixtures/file
       #   expand_path('%/file')
       #
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/CyclomaticComplexity
+      # @example Absolute directory
+      #
+      #   # => /foo/bar
+      #   expand_path('/foo/bar')
+      #
       def expand_path(file_name, dir_string = nil)
-        check_for_deprecated_variables if Aruba::VERSION < '1'
-
-        # rubocop:disable Metrics/LineLength
-        message = %(Filename "#{file_name}" needs to be a string. It cannot be nil or empty either.  Please use `expand_path('.')` if you want the current directory to be expanded.)
-        # rubocop:enable Metrics/LineLength
+        message = "Filename #{file_name} needs to be a string." \
+          ' It cannot be nil or empty either. '\
+          "Please use `expand_path('.')` if you want the current directory to be expanded."
 
-        fail ArgumentError, message unless file_name.is_a?(String) && !file_name.empty?
+        raise ArgumentError, message unless file_name.is_a?(String) && !file_name.empty?
 
-        # rubocop:disable Metrics/LineLength
-        aruba.logger.warn %(`aruba`'s working directory does not exist. Maybe you forgot to run `setup_aruba` before using it's API. This warning will be an error from 1.0.0) unless Aruba.platform.directory? File.join(aruba.config.root_directory, aruba.config.working_directory)
-        # rubocop:enable Metrics/LineLength
+        unless Aruba.platform.directory? File.join(aruba.config.root_directory,
+                                                   aruba.config.working_directory)
+          raise "Aruba's working directory does not exist." \
+            ' Maybe you forgot to run `setup_aruba` before using its API.'
+        end
 
         prefix = file_name[0]
         rest = file_name[2..-1]
 
         if aruba.config.fixtures_path_prefix == prefix
           path = File.join(*[aruba.fixtures_directory, rest].compact)
-
-          # rubocop:disable Metrics/LineLength
-          fail ArgumentError, %(Fixture "#{rest}" does not exist in fixtures directory "#{aruba.fixtures_directory}". This was the one we found first on your system from all possible candidates: #{aruba.config.fixtures_directories.map { |p| format('"%s"', p) }.join(', ')}.) unless Aruba.platform.exist? path
-          # rubocop:enable Metrics/LineLength
+          unless Aruba.platform.exist? path
+            aruba_fixture_candidates = aruba.config.fixtures_directories
+                                            .map { |p| format('"%s"', p) }.join(', ')
+
+            raise ArgumentError,
+                  "Fixture \"#{rest}\" does not exist" \
+                  " in fixtures directory \"#{aruba.fixtures_directory}\"." \
+                  ' This was the one we found first on your system from all possible' \
+                  " candidates: #{aruba_fixture_candidates}."
+          end
 
           path
-        elsif '~' == prefix
+        elsif prefix == '~'
           path = with_environment do
-            ArubaPath.new(File.expand_path(file_name))
+            File.expand_path(file_name)
           end
 
-          fail ArgumentError, 'Expanding "~/" to "/" is not allowed' if path.to_s == '/'
-          fail ArgumentError, %(Expanding "~/" to a relative path "#{path}" is not allowed) unless path.absolute?
+          raise ArgumentError, 'Expanding "~/" to "/" is not allowed' if path == '/'
+
+          unless Aruba.platform.absolute_path? path
+            raise ArgumentError,
+                  "Expanding \"~\" to a relative path \"#{path}\" is not allowed"
+          end
 
           path.to_s
+        elsif absolute?(file_name)
+          unless aruba.config.allow_absolute_paths
+            caller_location = caller_locations(1, 1).first
+            caller_file_line = "#{caller_location.path}:#{caller_location.lineno}"
+            aruba.logger.warn \
+              "Aruba's `expand_path` method was called with an absolute path" \
+              " at #{caller_file_line}, which is not recommended." \
+              ' Change the call to pass a relative path or set '\
+              '`config.allow_absolute_paths = true` to silence this warning'
+          end
+          file_name
         else
-          directory = File.join(aruba.root_directory, aruba.current_directory)
-          ArubaPath.new(File.join(*[directory, dir_string, file_name].compact)).expand_path.to_s
+          with_environment do
+            directory = File.expand_path(aruba.current_directory, aruba.root_directory)
+            directory = File.expand_path(dir_string, directory) if dir_string
+            File.expand_path(file_name, directory)
+          end
         end
       end
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable  Metrics/CyclomaticComplexity
 
       # Run block with environment
       #
@@ -168,14 +211,10 @@ module Aruba
       # @yield
       #   The block of code which should be run with the changed environment variables
       def with_environment(env = {}, &block)
-        old_aruba_env = aruba.environment.to_h
-
-        # make sure the old environment is really restored in "ENV"
-        Aruba.platform.with_environment aruba.environment.update(env).to_h, &block
-      ensure
-        # make sure the old environment is really restored in "aruba.environment"
-        aruba.environment.clear
-        aruba.environment.update old_aruba_env
+        aruba.environment.nest do |nested_env|
+          nested_env.update(env)
+          Aruba.platform.with_environment nested_env.to_h, &block
+        end
       end
     end
   end