aruba 0.6.2 → 0.7.0

data/Rakefile

@@ -8,7 +8,7 @@ require 'cucumber/rake/task'
 
 Cucumber::Rake::Task.new do |t|
   t.cucumber_opts = ""
-  t.cucumber_opts = "--format Cucumber::Pro --out cucumber-pro.log" if ENV['CUCUMBER_PRO_TOKEN']
+  # t.cucumber_opts = "--format Cucumber::Pro --out cucumber-pro.log" if ENV['CUCUMBER_PRO_TOKEN']
   t.cucumber_opts << "--format pretty"
 end
 

data/aruba.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'aruba'
-  s.version     = '0.6.2'
+  s.version     = '0.7.0'
   s.authors     = ["Aslak Hellesøy", "David Chelimsky", "Mike Sassak", "Matt Wynne"]
   s.description = 'CLI Steps for Cucumber, hand-crafted for you in Aruba'
   s.summary     = "aruba-#{s.version}"
@@ -13,15 +13,13 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'cucumber', '>= 1.1.1'
   s.add_runtime_dependency 'childprocess', '>= 0.3.6'
   s.add_runtime_dependency 'rspec-expectations', '>= 2.7.0'
-  s.add_development_dependency 'bcat', '>= 0.6.1'
-  s.add_development_dependency 'kramdown', '>= 0.14'
-  s.add_development_dependency 'rake', '>= 0.9.2'
-  s.add_development_dependency 'rspec', '>= 3.0.0'
-  s.add_development_dependency 'fuubar', '>= 1.1.1'
-  s.add_development_dependency 'cucumber-pro', '~> 0.0'
-  s.add_development_dependency 'rubocop', '~> 0.26.0'
+
+  s.add_development_dependency 'bundler', '~> 1.10.2'
 
   s.rubygems_version = ">= 1.6.1"
+  # s.required_ruby_version = '>= 2.0'
+  s.post_install_message = 'From aruba > 2.0 ruby 1.9.3-support is discontinued'
+
   s.files            = `git ls-files`.split("\n")
   s.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
   s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/cucumber.yml

@@ -1,10 +1,9 @@
 <%
 java_version = (RUBY_DESCRIPTION.match(/.*?on.*?(1\.[\d]\..*? )/))[1] if defined?(JRUBY_VERSION)
-std_opts = "--color --tags ~@wip"
-std_opts << " --tags ~@wip-jruby-java-1.6" if defined?(JRUBY_VERSION) && (java_version < '1.7.0')
 
-wip_opts = "--color --tags @wip:3"
-wip_opts = "--color --tags @wip:3,@wip-jruby-java-1.6:3" if defined?(JRUBY_VERSION) && (java_version < '1.7.0')
+std_opts          = "--color --exclude features/fixtures"
+java_default_opts = "--tags ~@wip-jruby-java-1.6" if defined?(JRUBY_VERSION) && (java_version < '1.7.0')
+java_wip_opts     = "--tags @wip-jruby-java-1.6:3" if defined?(JRUBY_VERSION) && (java_version < '1.7.0')
 %>
-default: <%= std_opts %>
-wip: --wip <%= wip_opts %>
+default: <%= std_opts %> --tags ~@wip <%= java_default_opts %>
+wip: <%= std_opts %> --wip --tags @wip:3 <%= java_wip_opts %>

data/features/debug.feature

@@ -0,0 +1,15 @@
+Feature: Debug command execution
+
+  As a developer
+  I want to use some debugger in my code and therefor need system() to execute my program
+  In order to find a bug
+
+  @debug
+  Scenario: Run program with debug code
+    When I run `true`
+    Then the exit status should be 0
+
+  @debug
+  Scenario: Run failing program with debug code
+    When I run `false`
+    Then the exit status should be 1

data/features/file_system_commands.feature

@@ -17,6 +17,14 @@ Feature: file system commands
     When I run `cat foo/bar/example.txt`
     Then the output should contain exactly "hello world"
 
+  Scenario: a file does not exist
+    Given a file named "example.txt" does not exist
+    Then the file "example.txt" should not exist
+
+  Scenario: a directory does not exist
+    Given a directory named "example.d" does not exist
+    Then the directory "foo" should not exist
+
   Scenario: create a fixed sized file
     Given a 1048576 byte file named "test.txt"
     Then a 1048576 byte file named "test.txt" should exist
@@ -125,7 +133,7 @@ Feature: file system commands
     Given a directory named "foo/bar"
     Then the following step should fail with Spec::Expectations::ExpectationNotMetError:
       """
-      Then a directory named "foo/bar" should not exist
+      Then the directory "foo/bar" should not exist
       """
 
   Scenario: Check file contents with text
@@ -185,7 +193,7 @@ Feature: file system commands
   Scenario: Remove directory
     Given a directory named "foo"
     When I remove the directory "foo"
-    Then a directory named "foo" should not exist
+    Then the directory "foo" should not exist
 
   Scenario: Just a dummy for reporting
     Given an empty file named "a/b.txt"
@@ -206,3 +214,7 @@ Feature: file system commands
     asdf
     """
     Then the mode of filesystem object "test.txt" should match "0666"
+
+  Scenario: Use a fixture
+    Given I use a fixture named "fixtures-app"
+    Then a file named "test.txt" should exist

data/features/fixtures/copy/file.txt

@@ -0,0 +1 @@
+asdf

data/features/fixtures/fixtures-app/test.txt

@@ -0,0 +1 @@
+asdf

data/features/fixtures/spawn_process/stderr.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+echo $* >&2

data/features/interactive.feature

@@ -62,5 +62,5 @@ Feature: Interactive process control
 
     Given a directory named "rename_me"
     When I run `mv rename_me renamed` interactively
-    Then a directory named "renamed" should exist
-    And a directory named "rename_me" should not exist
+    Then the directory "renamed" should exist
+    And the directory "rename_me" should not exist

data/features/step_definitions/aruba_dev_steps.rb

@@ -20,7 +20,7 @@ Then /^aruba should fail with "([^"]*)"$/ do |error_message|
 end
 
 Then /^the following step should fail with Spec::Expectations::ExpectationNotMetError:$/ do |multiline_step|
-  expect{steps multiline_step}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+  expect{steps multiline_step.to_s}.to raise_error(RSpec::Expectations::ExpectationNotMetError)
 end
 
 Then /^the output should be (\d+) bytes long$/ do |length|

data/features/support/custom_main.rb

@@ -1,12 +1,16 @@
 require 'aruba'
-require 'aruba/spawn_process'
-require 'aruba/in_process'
+require 'aruba/processes/spawn_process'
+require 'aruba/processes/in_process'
 require 'shellwords'
 require 'stringio'
 
 class CustomMain
   def initialize(argv, stdin, stdout, stderr, kernel)
-    @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+    @argv   = argv
+    @stdin  = stdin
+    @stdout = stdout
+    @stderr = stderr
+    @kernel = kernel
   end
 
   def execute!
@@ -15,10 +19,10 @@ class CustomMain
 end
 
 Before('@in-process') do
-  Aruba::InProcess.main_class = CustomMain
-  Aruba.process = Aruba::InProcess
+  Aruba.process = Aruba::Processes::InProcess
+  Aruba.process.main_class = CustomMain
 end
 
 After('~@in-process') do
-  Aruba.process = Aruba::SpawnProcess
+  Aruba.process = Aruba::Processes::SpawnProcess
 end

data/features/support/env.rb

@@ -1,4 +1,29 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'aruba/cucumber'
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
+
+# Has to be the first file required so that all other files show coverage information
+require 'simplecov'
+
+# Standard Library
 require 'fileutils'
+require 'pathname'
+
+# Gems
+require 'aruba/cucumber'
 require 'rspec/expectations'
+
+Before do |scenario|
+  command_name = case scenario
+                 when Cucumber::RunningTestCase::Scenario
+                   "#{scenario.feature.title} #{scenario.name}"
+                 else
+                   raise TypeError.new("Don't know how to extract command name from #{scenario.class}")
+                 end
+
+  # Used in simplecov_setup so that each scenario has a different name and their coverage results are merged instead
+  # of overwriting each other as 'Cucumber Features'
+  set_env('SIMPLECOV_COMMAND_NAME', command_name)
+
+  simplecov_setup_pathname = Pathname.new(__FILE__).expand_path.parent.join('simplecov_setup')
+  # set environment variable so child processes will merge their coverage data with parent process's coverage data.
+  set_env('RUBYOPT', "-r#{simplecov_setup_pathname} #{ENV['RUBYOPT']}")
+end

data/features/support/simplecov_setup.rb

@@ -0,0 +1,8 @@
+# @note this file is loaded in env.rb to setup simplecov using RUBYOPTs for child processes and @in-process
+require 'simplecov'
+
+root = File.expand_path('../../../', __FILE__)
+
+SimpleCov.command_name(ENV['SIMPLECOV_COMMAND_NAME'])
+SimpleCov.root(root)
+load File.join(root, '.simplecov')

data/lib/aruba.rb

@@ -1,8 +1,8 @@
-require 'aruba/spawn_process'
+require 'aruba/processes/spawn_process'
 
 module Aruba
   class << self
     attr_accessor :process
   end
-  self.process = Aruba::SpawnProcess
+  self.process = Aruba::Processes::SpawnProcess
 end

data/lib/aruba/announcer.rb

@@ -0,0 +1,161 @@
+module Aruba
+  # Announcer
+  #
+  # @example Activate your you own channel in cucumber
+  #
+  #   Before('@announce-my-channel') do
+  #     announcer.activate :my_channel
+  #   end
+  #
+  # @example Activate your you own channel in rspec > 3
+  #
+  #   before do
+  #     current_example = context.example
+  #     announcer.activate :my_channel if current_example.metadata[:announce_my_channel]
+  #   end
+  #
+  #   Aruba.announcer.announce(:my_channel, 'my message')
+  #
+  class Announcer
+    # Dev null
+    class NullAnnouncer
+      def announce(*)
+        nil
+      end
+
+      def mode?(*)
+        true
+      end
+    end
+
+    # Announcer using Kernel.puts
+    class KernelPutsAnnouncer
+      def announce(message)
+        Kernel.puts message
+      end
+
+      def mode?(m)
+        :kernel_puts == m
+      end
+    end
+
+    # Announcer using Main#puts
+    class PutsAnnouncer
+      def announce(message)
+        Kernel.puts message
+      end
+
+      def mode?(m)
+        :puts == m
+      end
+    end
+
+    private
+
+    attr_reader :announcers, :default_announcer, :announcer, :channels, :format_strings
+
+    public
+
+    def initialize(_, options)
+      @announcers = []
+      @announcers << PutsAnnouncer.new
+      @announcers << KernelPutsAnnouncer.new
+      @announcers << NullAnnouncer.new
+
+      @default_announcer = @announcers.last
+      @announcer         = @announcers.first
+      @channels          = {}
+      @format_strings    = {}
+
+      @options           = options
+
+      after_init
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def after_init
+      format_string :directory, '$ cd %s'
+      format_string :command, '$ %s'
+      format_string :environment, '$ export %s=%s"'
+
+      # rubocop:disable Metrics/LineLength
+      if @options[:stdout]
+        warn('The use of "@announce_stdout-instance" variable and "options[:stdout] = true" for Announcer.new is deprecated. Please use "announcer.activate(:stdout)" instead.')
+        activate :stdout
+      end
+      if @options[:stderr]
+        warn('The use of "@announce_stderr-instance" variable and "options[:stderr] = true" for Announcer.new is deprecated. Please use "announcer.activate(:stderr)" instead.')
+        activate :stderr
+      end
+      if @options[:dir]
+        warn('The use of "@announce_dir-instance" variable and "options[:dir] = true" for Announcer.new is deprecated. Please use "announcer.activate(:directory)" instead.')
+        activate :directory
+      end
+      if @options[:cmd]
+        warn('The use of "@announce_cmd-instance" variable and "options[:cmd] = true" for Announcer.new is deprecated. Please use "announcer.activate(:command)" instead.')
+        activate :command
+      end
+      if @options[:env]
+        warn('The use of "@announce_env-instance" variable and "options[:env] = true" for Announcer.new is deprecated. Please use "announcer.activate(:environment)" instead.')
+        activate :enviroment
+      end
+      # rubocop:enable Metrics/LineLength
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def reset
+      @default_announcer = @announcers.last
+      @announcer         = @announcers.first
+    end
+
+    def format_string(channel, string)
+      format_strings[channel] = string
+
+      self
+    end
+
+    def mode=(m)
+      @announcer = @announcers.find { |a| f.mode? m }
+
+      self
+    end
+
+    def activate(channel)
+      channels[channel] = true
+
+      self
+    end
+
+    def announce(channel, *args)
+      message = format(format_strings.fetch(channel, '%s'), *args)
+      announcer.announce(message) if @channels[channel]
+
+      default_announcer.announce message
+    end
+
+    def stdout(content)
+      warn('The announcer now has a new api to activate channels. Please use this one: announce(:stdout, message)')
+      announce :stdout, content
+    end
+
+    def stderr(content)
+      warn('The announcer now has a new api to activate channels. Please use this one: announce(:stderr, message)')
+      announce :stderr, content
+    end
+
+    def dir(dir)
+      warn('The announcer now has a new api to activate channels. Please use this one announce(:directory, message)')
+      announce :directory, dir
+    end
+
+    def cmd(cmd)
+      warn('The announcer now has a new api to activate channels. Please use this one announce(:command, message)')
+      announce :command, cmd
+    end
+
+    def env(key, value)
+      warn('The announcer now has a new api to activate channels. Please use this one: announce(:environment, key, value)')
+      announce :environment, key, value
+    end
+  end
+end

data/lib/aruba/api.rb

@@ -3,70 +3,222 @@ require 'rbconfig'
 require 'rspec/expectations'
 require 'aruba'
 require 'aruba/config'
+require 'aruba/errors'
+require 'aruba/process_monitor'
+require 'aruba/utils'
+require 'aruba/announcer'
+require 'ostruct'
+require 'pathname'
 
 Dir.glob( File.join( File.expand_path( '../matchers' , __FILE__ )  , '*.rb' ) ).each { |rb| require rb }
 
 module Aruba
   module Api
     include RSpec::Matchers
+    include Aruba::Utils
 
     # Expand file name
     #
     # @param [String] file_name
     #   Name of file
     #
+    # @param [String] dir_string
+    #   Name of directory to use as starting point, otherwise current directory is used.
+    #
     # @return [String]
     #   The full path
     #
     # @example Single file name
     #
     #   # => <path>/tmp/aruba/file
-    #   absolute_path('file')
+    #   expand_path('file')
     #
     # @example Single Dot
     #
     #   # => <path>/tmp/aruba
-    #   absolute_path('.')
+    #   expand_path('.')
+    #
+    # @example using home directory
     #
-    # @example Join and Expand path
+    #   # => <path>/home/<name>/file
+    #   expand_path('~/file')
     #
-    #   # => <path>/tmp/aruba/path/file
-    #   absolute_path('path', 'file')
+    # @example using fixtures directory
     #
+    #   # => <path>/test/fixtures/file
+    #   expand_path('%/file')
+    #
+    def expand_path(file_name, dir_string = nil)
+      message = "Filename cannot be nil or empty. Please use `expand_path('.')` if you want the current directory to be expanded."
+      # rubocop:disable Style/RaiseArgs
+      fail ArgumentError, message if file_name.nil? || file_name.empty?
+      # rubocop:enable Style/RaiseArgs
+
+      if FIXTURES_PATH_PREFIX == file_name[0]
+        File.join fixtures_directory, file_name[1..-1]
+      else
+        in_current_directory { File.expand_path file_name, dir_string }
+      end
+    end
+
+    # @private
+    # @deprecated
     def absolute_path(*args)
-      in_current_dir { File.expand_path File.join(*args) }
+      warn('The use of "absolute_path" is deprecated. Use "expand_path" instead. But be aware that "expand_path" uses a different implementation.')
+
+      in_current_directory { File.expand_path File.join(*args) }
     end
 
     # Execute block in current directory
     #
     # @yield
     #   The block which should be run in current directory
-    def in_current_dir(&block)
-      _mkdir(current_dir)
-      Dir.chdir(current_dir, &block)
+    def in_current_directory(&block)
+      _mkdir(current_directory)
+      Dir.chdir(current_directory, &block)
+    end
+
+    # Check if file or directory exist
+    #
+    # @param [String] file_or_directory
+    #   The file/directory which should exist
+    def exist?(file_or_directory)
+      File.exist? expand_path(file_or_directory)
+    end
+
+    # Check if file exist and is file
+    #
+    # @param [String] file
+    #   The file/directory which should exist
+    def file?(file)
+      File.file? expand_path(file)
+    end
+
+    # Check if directory exist and is directory
+    #
+    # @param [String] file
+    #   The file/directory which should exist
+    def directory?(file)
+      File.directory? expand_path(file)
+    end
+
+    # Check if path is absolute
+    #
+    # @return [TrueClass, FalseClass]
+    #   Result of check
+    def absolute?(path)
+      Pathname.new(path).absolute?
+    end
+
+    # Check if path is relative
+    #
+    # @return [TrueClass, FalseClass]
+    #   Result of check
+    def relative?(path)
+      Pathname.new(path).relative?
+    end
+
+    # Return all existing paths (directories, files) in current dir
+    #
+    # @return [Array]
+    #   List of files and directories
+    def all_paths
+      list('.').map { |p| expand_path(p) }
+    end
+
+    # Return all existing files in current directory
+    #
+    # @return [Array]
+    #   List of files
+    def all_files
+      list('.').select { |p| file? p }.map { |p| expand_path(p) }
+    end
+
+    # Return all existing directories in current directory
+    #
+    # @return [Array]
+    #   List of files
+    def all_directories
+      list('.').select { |p| directory? p }.map { |p| expand_path(p) }
+    end
+
+    # Create directory object
+    #
+    # @return [Dir]
+    #   The directory object
+    def directory(path)
+      fail ArgumentError, %(Path "#{name}" does not exist.) unless exist? name
+
+      Dir.new(expand_path(path))
+    end
+
+    # @deprecated
+    # @private
+    def in_current_dir(*args, &block)
+      warn('The use of "in_current_dir" is deprecated. Use "in_current_directory" instead')
+      in_current_directory(*args, &block)
     end
 
     # Clean the current directory
-    def clean_current_dir
-      _rm_rf(current_dir)
-      _mkdir(current_dir)
+    def clean_current_directory
+      _rm_rf(current_directory)
+      _mkdir(current_directory)
+    end
+
+    # @deprecated
+    # @private
+    def clean_current_dir(*args, &block)
+      warn('The use of "clean_current_dir" is deprecated. Use "clean_current_directory" instead')
+      clean_current_directory(*args, &block)
+    end
+
+    # Return content of directory
+    #
+    # @return [Array]
+    #   The content of directory
+    def list(name)
+      fail ArgumentError, %(Path "#{name}" does not exist.) unless exist? name
+      fail ArgumentError, %(Only directories are supported. Path "#{name}" is not a directory.) unless directory? name
+
+      existing_files            = Dir.glob(expand_path(File.join(name, '**', '*')))
+      current_working_directory = Pathname.new(expand_path('.'))
+
+      existing_files.map { |d| Pathname.new(d).relative_path_from(current_working_directory).to_s }
+    end
+
+    # Return content of file
+    #
+    # @return [Array]
+    #   The content of file
+    def read(name)
+      fail ArgumentError, %(Path "#{name}" does not exist.) unless exist? name
+      fail ArgumentError, %(Only files are supported. Path "#{name}" is not a file.) unless file? name
+
+      File.readlines(expand_path(name))
     end
 
     # Get access to current dir
     #
     # @return
     #   Current directory
-    def current_dir
+    def current_directory
       File.join(*dirs)
     end
 
+    # @deprecated
+    # @private
+    def current_dir(*args, &block)
+      warn('The use of "current_dir" is deprecated. Use "current_directory" instead')
+      current_directory(*args, &block)
+    end
+
     # Switch to directory
     #
     # @param [String] dir
     #   The directory
     def cd(dir)
       dirs << dir
-      raise "#{current_dir} is not a directory." unless File.directory?(current_dir)
+      raise "#{current_directory} is not a directory." unless File.directory?(current_directory)
     end
 
     # The path to the directory which should contain all your test data
@@ -92,20 +244,78 @@ module Aruba
       _create_file(file_name, file_content, false)
     end
 
+    # @private
+    # @deprecated
+    # Create an empty file
+    #
+    # @param [String] file_name
+    #   The name of the file
+    def touch_file(*args)
+      warn('The use of "touch_file" is deprecated. Use "touch" instead')
+
+      touch(*args)
+    end
+
     # Create an empty file
     #
     # @param [String] file_name
     #   The name of the file
-    def touch_file(file_name)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
-        _mkdir(File.dirname(file_name))
+    def touch(*args)
+      args = args.flatten
 
-        FileUtils.touch file_name
+      options = if args.last.kind_of? Hash
+                  args.pop
+                else
+                  {}
+                end
+
+      args = args.map { |p| expand_path(p) }
+      args.each { |p| _mkdir(File.dirname(p)) }
+
+      FileUtils.touch(args, options)
+
+      self
+    end
+
+    # Copy a file and/or directory
+    #
+    # @param [String, Array] source
+    #   A single file or directory, multiple files or directories or multiple
+    #   files and directories. If multiple sources are given the destination
+    #   needs to be a directory
+    #
+    # @param [String] destination
+    #   A file or directory name. If multiple sources are given the destination
+    #   needs to be a directory
+    #
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+    def copy(*source, destination)
+      source = source.flatten
+
+      source.each do |s|
+        raise ArgumentError, %(The following source "#{s}" does not exist.) unless exist? s
       end
 
+      raise ArgumentError, "Using a fixture as destination (#{destination}) is not supported" if destination.start_with? FIXTURES_PATH_PREFIX
+      raise ArgumentError, "Multiples sources can only be copied to a directory" if source.count > 1 && exist?(destination) && !directory?(destination)
+
+      source_paths     = source.map { |f| expand_path(f) }
+      destination_path = expand_path(destination)
+
+      if source_paths.count > 1
+        _mkdir(destination_path)
+      else
+        _mkdir(File.dirname(destination_path))
+        source_paths = source_paths.first
+      end
+
+      FileUtils.cp_r source_paths, destination_path
+
       self
     end
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
 
     # Create a file with the given size
     #
@@ -132,14 +342,12 @@ module Aruba
 
     # @private
     def _create_file(file_name, file_content, check_presence)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+      file_name = expand_path(file_name)
 
-        raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
+      raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
 
-        _mkdir(File.dirname(file_name))
-        File.open(file_name, 'w') { |f| f << file_content }
-      end
+      _mkdir(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
 
       self
     end
@@ -151,17 +359,28 @@ module Aruba
     #
     # @param [String] file_name
     #   Name of file to be modified. This file needs to be present to succeed
-    def filesystem_permissions(mode, file_name)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+    def filesystem_permissions(*args)
+      args = args.flatten
 
-        raise "expected #{file_name} to be present" unless FileTest.exists?(file_name)
-        if mode.kind_of? String
-          FileUtils.chmod(mode.to_i(8),file_name)
-        else
-          FileUtils.chmod(mode, file_name)
-        end
-      end
+      options = if args.last.kind_of? Hash
+                  args.pop
+                else
+                  {}
+                end
+
+      mode = args.shift
+      mode = if mode.kind_of? String
+               mode.to_i(8)
+             else
+               mode
+             end
+
+      args = args.map { |p| expand_path(p) }
+      args.each { |p| raise "Expected #{p} to be present" unless FileTest.exists?(p) }
+
+      FileUtils.chmod(mode, args, options)
+
+      self
     end
 
     # @private
@@ -174,29 +393,27 @@ module Aruba
 
     # Check file system permissions of file
     #
-    # @param [Octal] mode
+    # @param [Octal] expected_permissions
     #   Expected file system permissions, e.g. 0755
-    # @param [String] file_name
-    #   Expected file system permissions, e.g. 0755
-    # @param [Boolean] expect_permissions
+    # @param [String] file_names
+    #   The file name(s)
+    # @param [Boolean] expected_result
     #   Are the permissions expected to be mode or are they expected not to be mode?
-    def check_filesystem_permissions(mode, file_name, expect_permissions)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+    def check_filesystem_permissions(*args)
+      args = args.flatten
 
-        raise "expected #{file_name} to be present" unless FileTest.exists?(file_name)
-        if mode.kind_of? Integer
-          expected_mode = mode.to_s(8)
-        else
-          expected_mode = mode.gsub(/^0*/, '')
-        end
+      expected_permissions = args.shift
+      expected_result      = args.pop
 
-        file_mode = sprintf( "%o", File::Stat.new(file_name).mode )[-4,4].gsub(/^0*/, '')
+      args = args.map { |p| expand_path(p) }
 
-        if expect_permissions
-          expect(file_mode).to eq expected_mode
+      args.each do |p|
+        raise "Expected #{p} to be present" unless FileTest.exists?(p)
+
+        if expected_result
+          expect(p).to have_permissions expected_permissions
         else
-          expect(file_mode).not_to eq expected_mode
+          expect(p).not_to have_permissions expected_permissions
         end
       end
     end
@@ -211,25 +428,23 @@ module Aruba
 
     # @private
     def _create_fixed_size_file(file_name, file_size, check_presence)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+      file_name = expand_path(file_name)
 
-        raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
-        _mkdir(File.dirname(file_name))
-        File.open(file_name, "wb"){ |f| f.seek(file_size - 1); f.write("\0") }
-      end
+      raise "expected #{file_name} to be present" if check_presence && !File.file?(file_name)
+      _mkdir(File.dirname(file_name))
+      File.open(file_name, "wb"){ |f| f.seek(file_size - 1); f.write("\0") }
     end
 
+    # @private
+    # @deprecated
     # Remove file
     #
     # @param [String] file_name
     #    The file which should be deleted in current directory
-    def remove_file(file_name)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+    def remove_file(*args)
+      warn('The use of "remove_file" is deprecated. Use "remove" instead')
 
-        FileUtils.rm(file_name)
-      end
+      remove(*args)
     end
 
     # Append data to file
@@ -240,38 +455,67 @@ module Aruba
     # @param [String] file_content
     #   The content which should be appended to file
     def append_to_file(file_name, file_content)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+      file_name = expand_path(file_name)
 
-        _mkdir(File.dirname(file_name))
-        File.open(file_name, 'a') { |f| f << file_content }
-      end
+      _mkdir(File.dirname(file_name))
+      File.open(file_name, 'a') { |f| f << file_content }
     end
 
     # Create a directory in current directory
     #
     # @param [String] directory_name
     #   The name of the directory which should be created
-    def create_dir(directory_name)
-      in_current_dir do
-        _mkdir(directory_name)
-      end
+    def create_directory(directory_name)
+      FileUtils.mkdir_p expand_path(directory_name)
 
       self
     end
 
+    # @private
+    # @deprecated
+    def create_dir(*args)
+      warn('The use of "create_dir" is deprecated. Use "create_directory" instead')
+      create_directory(*args)
+    end
+
+    # Remove file or directory
+    #
+    # @param [Array, String] name
+    #   The name of the file / directory which should be removed
+    def remove(*args)
+      args = args.flatten
+
+      options = if args.last.kind_of? Hash
+                  args.pop
+                else
+                  {}
+                end
+
+      args = args.map { |p| expand_path(p) }
+
+      FileUtils.rm_r(args, options)
+    end
+
+    # @private
+    # @deprecated
     # Remove directory
     #
     # @param [String] directory_name
     #   The name of the directory which should be removed
-    def remove_dir(directory_name)
-      in_current_dir do
-        directory_name = File.expand_path(directory_name)
+    def remove_directory(*args)
+      warn('The use of "remove_directory" is deprecated. Use "remove" instead')
+      remove(*args)
+    end
 
-        FileUtils.rmdir(directory_name)
-      end
+    # @private
+    # @deprecated
+    def remove_dir(*args)
+      warn('The use of "remove_dir" is deprecated. Use "remove" instead')
+      remove(*args)
     end
 
+    # @deprecated
+    #
     # Check if paths are present
     #
     # @param [#each] paths
@@ -280,22 +524,22 @@ module Aruba
     # @param [true,false] expect_presence
     #   Should the given paths be present (true) or absent (false)
     def check_file_presence(paths, expect_presence = true)
-      prep_for_fs_check do
-        Array(paths).each do |path|
-          if path.kind_of? Regexp
-            if expect_presence
-              expect(Dir.glob('**/*')).to include_regexp(path)
-            else
-              expect(Dir.glob('**/*')).not_to include_regexp(path)
-            end
-          else
-            path = File.expand_path(path)
+      warn('The use of "check_file_presence" is deprecated. Use "expect().to be_existing_file or expect(all_paths).to match_path_pattern() instead" ')
+
+      stop_processes!
 
-            if expect_presence
-              expect(File).to be_file(path)
-            else
-              expect(File).not_to be_file(path)
-            end
+      Array(paths).each do |path|
+        if path.kind_of? Regexp
+          if expect_presence
+            expect(all_paths).to match_path_pattern(path)
+          else
+            expect(all_paths).not_to match_path_pattern(path)
+          end
+        else
+          if expect_presence
+            expect(path).to be_existing_file
+          else
+            expect(path).not_to be_existing_file
           end
         end
       end
@@ -306,12 +550,10 @@ module Aruba
     # @param [String] file_name
     #   The file which should be used to pipe in data
     def pipe_in_file(file_name)
-      in_current_dir do
-        file_name = File.expand_path(file_name)
+      file_name = expand_path(file_name)
 
-        File.open(file_name, 'r').each_line do |line|
-          _write_interactive(line)
-        end
+      File.open(file_name, 'r').each_line do |line|
+        last_command.write(line)
       end
     end
 
@@ -329,12 +571,12 @@ module Aruba
     #   check_file_size(paths_and_sizes)
     #
     def check_file_size(paths_and_sizes)
-      prep_for_fs_check do
-        paths_and_sizes.each do |path, size|
-          path = File.expand_path(path)
+      stop_processes!
 
-          expect(File.size(path)).to eq size
-        end
+      paths_and_sizes.each do |path, size|
+        path = expand_path(path)
+
+        expect(File.size(path)).to eq size
       end
     end
 
@@ -346,12 +588,12 @@ module Aruba
     # @yield
     #   Pass the content of the given file to this block
     def with_file_content(file, &block)
-      prep_for_fs_check do
-        file = File.expand_path(file)
+      stop_processes!
 
-        content = IO.read(file)
-        yield(content)
-      end
+      file = expand_path(file)
+      content = IO.read(file)
+
+      yield(content)
     end
 
     # Check the content of file
@@ -370,19 +612,21 @@ module Aruba
     # @param [true, false] expect_match
     #   Must the content be in the file or not
     def check_file_content(file, content, expect_match = true)
+      stop_processes!
+
       match_content =
         if(Regexp === content)
           match(content)
         else
           eq(content)
         end
-      prep_for_fs_check do
-        content = IO.read(File.expand_path(file))
-        if expect_match
-          expect(content).to match_content
-        else
-          expect(content).not_to match_content
-        end
+
+      content = IO.read(expand_path(file))
+
+      if expect_match
+        expect(content).to match_content
+      else
+        expect(content).not_to match_content
       end
     end
 
@@ -405,13 +649,10 @@ module Aruba
     # @param [true, false] expect_match
     #   Must the content be in the file or not
     def check_binary_file_content(file, reference_file, expect_match = true)
-      prep_for_fs_check do
-        identical = FileUtils.compare_file(file, reference_file)
-        if expect_match
-          expect(identical).to be(true), "The file \"#{file}\" differs from file \"#{reference_file}\""
-        else
-          expect(identical).not_to be(true), "The file \"#{file}\" is identical to file \"#{reference_file}\""
-        end
+      if expect_match
+        expect(file).to have_same_file_content_like reference_file
+      else
+        expect(file).not_to have_same_file_content_like reference_file
       end
     end
 
@@ -423,23 +664,25 @@ module Aruba
     # @param [true, false] expect_presence
     #   Should the directory be there or should the directory not be there
     def check_directory_presence(paths, expect_presence)
-      prep_for_fs_check do
-        paths.each do |path|
-          path = File.expand_path(path)
+      stop_processes!
 
-          if expect_presence
-            expect(File).to be_directory(path)
-          else
-            expect(File).not_to be_directory(path)
-          end
+      paths.each do |path|
+        path = expand_path(path)
+
+        if expect_presence
+          expect(File).to be_directory(path)
+        else
+          expect(File).not_to be_directory(path)
         end
       end
     end
 
     # @private
     def prep_for_fs_check(&block)
-      stop_processes!
-      in_current_dir{ block.call }
+      warn('The use of "prep_for_fs_check" is deprecated. It will be removed soon.')
+
+      process_monitor.stop_processes!
+      in_current_directory{ block.call }
     end
 
     # @private
@@ -472,28 +715,25 @@ module Aruba
     # Fetch output (stdout, stderr) from command
     #
     # @param [String] cmd
-    #   The comand
+    #   The command
     def output_from(cmd)
-      cmd = detect_ruby(cmd)
-      get_process(cmd).output
+      process_monitor.output_from(cmd)
     end
 
     # Fetch stdout from command
     #
     # @param [String] cmd
-    #   The comand
+    #   The command
     def stdout_from(cmd)
-      cmd = detect_ruby(cmd)
-      get_process(cmd).stdout
+      process_monitor.stdout_from(cmd)
     end
 
     # Fetch stderr from command
     #
     # @param [String] cmd
-    #   The comand
+    #   The command
     def stderr_from(cmd)
-      cmd = detect_ruby(cmd)
-      get_process(cmd).stderr
+      process_monitor.stderr_from(cmd)
     end
 
     # Get stdout of all processes
@@ -501,8 +741,7 @@ module Aruba
     # @return [String]
     #   The stdout of all process which have run before
     def all_stdout
-      stop_processes!
-      only_processes.inject("") { |out, ps| out << ps.stdout }
+      process_monitor.all_stdout
     end
 
     # Get stderr of all processes
@@ -510,8 +749,7 @@ module Aruba
     # @return [String]
     #   The stderr of all process which have run before
     def all_stderr
-      stop_processes!
-      only_processes.inject("") { |out, ps| out << ps.stderr }
+      process_monitor.all_stderr
     end
 
     # Get stderr and stdout of all processes
@@ -519,7 +757,7 @@ module Aruba
     # @return [String]
     #   The stderr and stdout of all process which have run before
     def all_output
-      all_stdout << all_stderr
+      process_monitor.all_output
     end
 
     # Full compare arg1 and arg2
@@ -546,7 +784,7 @@ module Aruba
     #   If arg2 matches arg1 return true, otherwise false
     def assert_matching_output(expected, actual)
       actual.force_encoding(expected.encoding) if RUBY_VERSION >= "1.9"
-      expect(unescape(actual)).to match /#{unescape(expected)}/m
+      expect(unescape(actual)).to match(/#{unescape(expected)}/m)
     end
 
     # Negative regex compare arg1 and arg2
@@ -576,7 +814,7 @@ module Aruba
     # @return [TrueClass, FalseClass]
     #   If output of interactive command includes arg1 return true, otherwise false
     def assert_partial_output_interactive(expected)
-      unescape(_read_interactive).include?(unescape(expected)) ? true : false
+      unescape(last_command.stdout).include?(unescape(expected)) ? true : false
     end
 
     # Check if command succeeded and if arg1 is included in output
@@ -624,13 +862,16 @@ module Aruba
     #   If arg1 is true, return true if command was successful
     #   If arg1 is false, return true if command failed
     def assert_success(success)
-      success ? assert_exit_status(0) : assert_not_exit_status(0)
+      if success
+        expect(last_command).to be_successfully_executed
+      else
+        expect(last_command).not_to be_successfully_executed
+      end
     end
 
     # @private
     def assert_exit_status(status)
-      expect(last_exit_status).to eq(status),
-        append_output_to("Exit status was #{last_exit_status} but expected it to be #{status}.")
+      expect(last_command).to have_exit_status(status)
     end
 
     # @private
@@ -644,41 +885,43 @@ module Aruba
       "#{message} Output:\n\n#{all_output}\n"
     end
 
+    def process_monitor
+      @process_monitor ||= ProcessMonitor.new(announcer)
+    end
+
     # @private
     def processes
-      @processes ||= []
+      process_monitor.send(:processes)
     end
 
     # @private
     def stop_processes!
-      processes.each do |_, process|
-        stop_process(process)
-      end
+      process_monitor.stop_processes!
     end
 
     # Terminate all running processes
     def terminate_processes!
-      processes.each do |_, process|
-        terminate_process(process)
-        stop_process(process)
-      end
+      process_monitor.terminate_processes!
+    end
+
+    # @private
+    def last_command
+      processes.last[1]
     end
 
     # @private
-    def register_process(name, process)
-      processes << [name, process]
+    def register_process(*args)
+      process_monitor.register_process(*args)
     end
 
     # @private
     def get_process(wanted)
-      matching_processes = processes.reverse.find{ |name, _| name == wanted }
-      raise ArgumentError.new("No process named '#{wanted}' has been started") unless matching_processes
-      matching_processes.last
+      process_monitor.get_process(wanted)
     end
 
     # @private
     def only_processes
-      processes.collect{ |_, process| process }
+      process_monitor.only_processes
     end
 
     # Run given command and stop it if timeout is reached
@@ -688,6 +931,9 @@ module Aruba
     #
     # @param [Integer] timeout
     #   If the timeout is reached the command will be killed
+    #
+    # @yield [SpawnProcess]
+    #   Run block with process
     def run(cmd, timeout = nil)
       timeout ||= exit_timeout
       @commands ||= []
@@ -695,18 +941,16 @@ module Aruba
 
       cmd = detect_ruby(cmd)
 
-      in_current_dir do
-        Aruba.config.hooks.execute(:before_cmd, self, cmd)
+      Aruba.config.hooks.execute(:before_cmd, self, cmd)
 
-        announcer.dir(Dir.pwd)
-        announcer.cmd(cmd)
+      announcer.announce(:directory, Dir.pwd)
+      announcer.announce(:command, cmd)
 
-        process = Aruba.process.new(cmd, timeout, io_wait)
-        register_process(cmd, process)
-        process.run!
+      process = Aruba.process.new(cmd, timeout, io_wait, expand_path('.'))
+      process_monitor.register_process(cmd, process)
+      process.run!
 
-        block_given? ? yield(process) : process
-      end
+      block_given? ? yield(process) : process
     end
 
     DEFAULT_TIMEOUT_SECONDS = 3
@@ -729,6 +973,37 @@ module Aruba
       @aruba_io_wait_seconds || DEFAULT_IO_WAIT_SECONDS
     end
 
+    DEFAULT_ROOT_DIRECTORY = Dir.getwd
+
+    # The root directory of aruba
+    def root_directory
+      @aruba_root_directory || DEFAULT_ROOT_DIRECTORY
+    end
+
+    # Path prefix for fixtures
+    FIXTURES_PATH_PREFIX = ?%
+
+    DEFAULT_FIXTURES_DIRECTORIES = %w(
+      features/fixtures
+      spec/fixtures
+      test/fixtures
+    )
+
+    # The path to the directory which contains fixtures
+    # You might want to overwrite this method to place your data else where.
+    #
+    # @return [String]
+    #   The directory to where your fixtures are stored
+    def fixtures_directory
+      unless @fixtures_directory
+        candidates = DEFAULT_FIXTURES_DIRECTORIES.map { |dir| File.join(root_directory, dir) }
+        @fixtures_directory = candidates.find { |dir| File.directory? dir }
+        raise "No fixtures directories are found" unless @fixtures_directory
+      end
+      raise "#{@fixtures_directory} is not a directory" unless File.directory?(@fixtures_directory)
+      @fixtures_directory
+    end
+
     # Run a command with aruba
     #
     # Checks for error during command execution and checks the output to detect
@@ -743,11 +1018,15 @@ module Aruba
     # @param [Integer] timeout
     #   Timeout for execution
     def run_simple(cmd, fail_on_error = true, timeout = nil)
-      run(cmd, timeout) do |process|
-        stop_process(process)
+      command = run(cmd, timeout) do |process|
+        process_monitor.stop_process(process)
+
+        process
       end
-      @timed_out = last_exit_status.nil?
-      assert_exit_status(0) if fail_on_error
+
+      @timed_out = command.exit_status.nil?
+
+      expect(command).to be_successfully_executed if fail_on_error
     end
 
     # Run a command interactively
@@ -756,8 +1035,12 @@ module Aruba
     #   The command to by run
     #
     # @see #cmd
+    # @deprectated
+    # @private
     def run_interactive(cmd)
-      @interactive = run(cmd)
+      warn('The use of "run_interactive" is deprecated. You can simply use "run" instead.')
+
+      run(cmd)
     end
 
     # Provide data to command via stdin
@@ -766,12 +1049,12 @@ module Aruba
     #   The input for the command
     def type(input)
       return close_input if "" == input
-      _write_interactive(_ensure_newline(input))
+      last_command.write(_ensure_newline(input))
     end
 
     # Close stdin
     def close_input
-      @interactive.stdin.close
+      last_command.close_io(:stdin)
     end
 
     # @deprecated
@@ -783,18 +1066,21 @@ module Aruba
 
     # @private
     def _write_interactive(input)
-      @interactive.stdin.write(input)
-      @interactive.stdin.flush
+      warn('The use of "_write_interactive" is deprecated. It will be removed soon.')
+
+      last_command.write(input)
     end
 
     # @private
     def _read_interactive
-      @interactive.read_stdout
+      warn('The use of "_read_interactive" is deprecated. It will be removed soon.')
+
+      last_command.stdout
     end
 
     # @private
     def _ensure_newline(str)
-      str.chomp << "\n"
+      Utils.ensure_newline(str)
     end
 
     # @private
@@ -806,20 +1092,6 @@ module Aruba
       end
     end
 
-    # @private
-    def detect_ruby(cmd)
-      if cmd =~ /^ruby\s/
-        cmd.gsub(/^ruby\s/, "#{current_ruby} ")
-      else
-        cmd
-      end
-    end
-
-    # @private
-    def current_ruby
-      File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-    end
-
     # Use a clean rvm gemset
     #
     # Please make sure that you've got [rvm](http://rvm.io/) installed.
@@ -859,7 +1131,7 @@ module Aruba
     # @param [String] value
     #   The value of the environment variable. Needs to be a string.
     def set_env(key, value)
-      announcer.env(key, value)
+      announcer.announce(:environment, key, value)
       original_env[key] = ENV.delete(key) unless original_env.key? key
       ENV[key] = value
     end
@@ -895,69 +1167,36 @@ module Aruba
       restore_env
     end
 
+    # Access to announcer
+    def announcer
+      @announcer ||= Announcer.new(
+        self,
+        :stdout => @announce_stdout,
+        :stderr => @announce_stderr,
+        :dir    => @announce_dir,
+        :cmd    => @announce_cmd,
+        :env    => @announce_env
+      )
+
+      @announcer
+    end
+
+    module_function :announcer
+
     # TODO: move some more methods under here!
 
     private
 
     def last_exit_status
-      return @last_exit_status if @last_exit_status
-      stop_processes!
-      @last_exit_status
+      process_monitor.last_exit_status
     end
 
     def stop_process(process)
-      @last_exit_status = process.stop(announcer)
+      process_monitor.stop_process(process)
     end
 
     def terminate_process(process)
-      process.terminate
-    end
-
-    def announcer
-      Announcer.new(self,
-                    :stdout => @announce_stdout,
-                    :stderr => @announce_stderr,
-                    :dir => @announce_dir,
-                    :cmd => @announce_cmd,
-                    :env => @announce_env)
+      process_monitor.terminate_process(process)
     end
-
-    class Announcer
-      def initialize(session, options = {})
-        @session, @options = session, options
-      end
-
-      def stdout(content)
-        return unless @options[:stdout]
-        print content
-      end
-
-      def stderr(content)
-        return unless @options[:stderr]
-        print content
-      end
-
-      def dir(dir)
-        return unless @options[:dir]
-        print "$ cd #{dir}"
-      end
-
-      def cmd(cmd)
-        return unless @options[:cmd]
-        print "$ #{cmd}"
-      end
-
-      def env(key, value)
-        return unless @options[:env]
-        print %{$ export #{key}="#{value}"}
-      end
-
-      private
-
-      def print(message)
-        @session.announce_or_puts(message)
-      end
-    end
-
   end
 end