aruba 0.7.4 → 0.8.0.pre

data/lib/aruba/basic_configuration.rb

@@ -0,0 +1,208 @@
+require 'contracts'
+require 'aruba/basic_configuration/option'
+
+module Aruba
+  # Basic configuration for ProxyPacRb
+  class BasicConfiguration
+    include Contracts
+
+    class << self
+      def known_options
+        @known_options ||= {}
+      end
+
+      def option_reader(name, opts = {})
+        contract = opts[:contract]
+        default  = opts[:default]
+
+        fail ArgumentError, 'Either use block or default value' if block_given? && default
+        fail ArgumentError, 'contract-options is required' if contract.nil?
+
+        Contract contract
+        add_option(name, block_given? ? yield(ConfigWrapper.new(known_options)) : default)
+
+        define_method(name) { find_option(name).value }
+
+        self
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def option_accessor(name, opts = {})
+        contract = opts[:contract]
+        default  = opts[:default]
+
+        fail ArgumentError, 'Either use block or default value' if block_given? && default
+        fail ArgumentError, 'Either use block or default value' if !block_given? && default.nil? && default.empty?
+        fail ArgumentError, 'contract-options is required' if contract.nil?
+
+        # Add writer
+        add_option(name, block_given? ? yield(ConfigWrapper.new(known_options)) : default)
+
+        Contract contract
+        define_method("#{name}=") { |v| find_option(name).value = v }
+
+        # Add reader
+        option_reader name, :contract => { None => contract.values.first }
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      private
+
+      def add_option(name, value = nil)
+        return if known_options.key?(name)
+
+        known_options[name] = Option.new(:name => name, :value => value)
+
+        self
+      end
+    end
+
+    protected
+
+    attr_accessor :local_options
+    attr_writer :hooks
+
+    # attr_reader :hooks
+
+    public
+
+    def initialize
+      initialize_configuration
+    end
+
+    # @yield [Configuration]
+    #
+    #   Yields self
+    def configure
+      yield self if block_given?
+    end
+
+    # Reset configuration
+    def reset
+      initialize_configuration
+    end
+
+    # Make deep dup copy of configuration
+    def make_copy
+      obj = self.dup
+      obj.local_options = Marshal.load(Marshal.dump(local_options))
+      obj.hooks         = @hooks
+
+      obj
+    end
+
+    # Get access to hooks
+    def hooks
+      # rubocop:disable Metrics/LineLength
+      Aruba::Platform.deprecated 'The use of the "#aruba.config.hooks" is deprecated. Please use "#aruba.config.before(:name) {}" to define and "#aruba.config.before(:name, *args)" to run a hook. This method will become private in the next major version.'
+      # rubocop:enable Metrics/LineLength
+
+      @hooks
+    end
+
+    # @deprecated
+    def before_cmd(&block)
+      Aruba::Platform.deprecated 'The use of the "#before_cmd"-hook is deprecated. Please define with "#before(:command) {}" instead'
+
+      before(:command, &block)
+    end
+
+    # Define or run before-hook
+    #
+    # @param [Symbol, String] name
+    #   The name of the hook
+    #
+    # @param [Proc] context
+    #   The context a hook should run in. This is a runtime only option.
+    #
+    # @param [Array] args
+    #   Arguments for the run of hook. This is a runtime only option.
+    #
+    # @yield
+    #   The code block which should be run. This is a configure time only option
+    def before(name, context = proc {}, *args, &block)
+      name = format('%s_%s', 'before_', name.to_s).to_sym
+
+      if block_given?
+        @hooks.append(name, block)
+
+        self
+      else
+        @hooks.execute(name, context, *args)
+      end
+    end
+
+    # Define or run after-hook
+    #
+    # @param [Symbol, String] name
+    #   The name of the hook
+    #
+    # @param [Proc] context
+    #   The context a hook should run in. This is a runtime only option.
+    #
+    # @param [Array] args
+    #   Arguments for the run of hook. This is a runtime only option.
+    #
+    # @yield
+    #   The code block which should be run. This is a configure time only option
+    def after(name, context = proc {}, *args, &block)
+      name = format('%s_%s', 'after_', name.to_s).to_sym
+
+      if block_given?
+        @hooks.append(name, block)
+
+        self
+      else
+        @hooks.execute(name, context, *args)
+      end
+    end
+
+    # Check if before-hook <name> is defined
+    def before?(name)
+      name = format('%s_%s', 'before_', name.to_s).to_sym
+
+      @hooks.exist? name
+    end
+
+    # Check if after-hook <name> is defined
+    def after?(name)
+      name = format('%s_%s', 'after_', name.to_s).to_sym
+
+      @hooks.exist? name
+    end
+
+    # Check if <name> is option
+    #
+    # @param [String, Symbol] name
+    #   The name of the option
+    def option?(name)
+      local_options.any? { |_, v| v.name == name.to_sym }
+    end
+
+    def ==(other)
+      local_options.values.map(&:value) == other.local_options.values.map(&:value)
+    end
+
+    # Set if name is option
+    def set_if_option(name, *args)
+      if RUBY_VERSION < '1.9'
+        send("#{name}=".to_sym, *args) if option? name
+      else
+        public_send("#{name}=".to_sym, *args) if option? name
+      end
+    end
+
+    private
+
+    def initialize_configuration
+      @local_options = Marshal.load(Marshal.dump(self.class.known_options))
+      @hooks         = Hooks.new
+    end
+
+    def find_option(name)
+      fail NotImplementedError, %(Unknown option "#{name}") unless option? name
+
+      local_options[name]
+    end
+  end
+end

data/lib/aruba/basic_configuration/option.rb

@@ -0,0 +1,25 @@
+module Aruba
+  class BasicConfiguration
+    # A configuration option
+    class Option
+      attr_accessor :name, :value
+      attr_reader :default_value
+
+      def initialize(opts = {})
+        name = opts[:name]
+        value = opts[:value]
+
+        fail ArgumentError, '"name" is required' if name.nil?
+        fail ArgumentError, '"value" is required' if value.nil?
+
+        @name          = name
+        @value         = value
+        @default_value = value
+      end
+
+      def ==(other)
+        name == other.name && value == other.value
+      end
+    end
+  end
+end

data/lib/aruba/config.rb

@@ -1,43 +1,56 @@
-module Aruba
-  class Config
-    attr_reader :hooks
+require 'contracts'
+require 'aruba/basic_configuration'
+require 'aruba/config_wrapper'
+require 'aruba/hooks'
+require 'aruba/contracts/relative_path'
 
-    def initialize
-      @hooks = Hooks.new
+module Aruba
+  # Aruba Configuration
+  class Configuration < BasicConfiguration
+    # As of 1.0.0 root_directory is read-only
+    # option_reader   :root_directory, :contract => { None => String }, :default => Dir.getwd
+    option_accessor   :root_directory, :contract => { String => String }, :default => Dir.getwd
+    option_accessor :working_directory, :contract => { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath }, :default => 'tmp/aruba'
+
+    if RUBY_VERSION < '1.9'
+      option_reader   :fixtures_path_prefix, :contract => { None => String }, :default => '%'
+    else
+      option_reader   :fixtures_path_prefix, :contract => { None => String }, :default => ?%
     end
 
-    # Register a hook to be called before Aruba runs a command
-    def before_cmd(&block)
-      @hooks.append(:before_cmd, block)
-    end
+    option_accessor :exit_timeout, :contract => { Num => Num }, :default => 15
+    option_accessor :io_wait_timeout, :contract => { Num => Num }, :default => 0.1
+    option_accessor :fixtures_directories, :contract => { Array => ArrayOf[String] }, :default => %w(features/fixtures spec/fixtures test/fixtures)
+    option_accessor :command_runtime_environment, :contract => { Hash => Hash }, :default => ENV.to_hash
+    option_accessor(:command_search_paths, :contract => { ArrayOf[String] => ArrayOf[String] }) { |config| [File.join(config.root_directory.value, 'bin')] }
+    option_accessor :keep_ansi, :contract => { Bool => Bool }, :default => false
   end
+end
 
-  #nodoc
-  class Hooks
-    def initialize
-      @store = Hash.new do |hash, key|
-        hash[key] = []
-      end
-    end
+# Main Module
+module Aruba
+  @config = Configuration.new
 
-    def append(label, block)
-      @store[label] << block
-    end
+  class << self
+    attr_reader :config
+
+    def configure(&block)
+      @config.configure(&block)
 
-    def execute(label, context, *args)
-      @store[label].each do |block|
-        context.instance_exec(*args, &block)
-      end
+      self
     end
   end
+end
 
-  class << self
-    attr_accessor :config
-
-    def configure
-      yield config
+module Aruba
+  # Old Config
+  #
+  # @private
+  class Config < Configuration
+    def initialize(*args)
+      warn('The use of "Aruba::Config" is deprecated. Use "Aruba::Configuration" instead.')
+
+      super
     end
   end
-
-  self.config = Config.new
 end

data/lib/aruba/config/jruby.rb

@@ -0,0 +1,14 @@
+require 'rbconfig'
+
+# ideas taken from: http://blog.headius.com/2010/03/jruby-startup-time-tips.html
+Aruba.configure do |config|
+  config.before :command do
+    next unless RUBY_PLATFORM == 'java'
+
+    # disable JIT since these processes are so short lived
+    ENV['JRUBY_OPTS'] = "-X-C #{ENV['JRUBY_OPTS']}"
+
+    # force jRuby to use client JVM for faster startup times
+    ENV['JAVA_OPTS'] = "-d32 #{ENV['JAVA_OPTS']}" if RbConfig::CONFIG['host_os'] =~ /solaris|sunos/i
+  end
+end

data/lib/aruba/config_wrapper.rb

@@ -0,0 +1,17 @@
+module Aruba
+  class ConfigWrapper
+    attr_reader :config
+    private :config
+
+    def initialize(config)
+      @config = config.dup
+    end
+
+    def method_missing(name, *args)
+      fail ArgumentError, 'Options take no argument' if args.count > 0
+      fail UnknownOptionError, %(Option "#{name}" is unknown. Please use only earlier defined options) unless config.key? name
+
+      config[name]
+    end
+  end
+end

data/lib/aruba/contracts/relative_path.rb

@@ -0,0 +1,13 @@
+require 'aruba/aruba_path'
+
+module Aruba
+  module Contracts
+    class RelativePath
+      def self.valid?(value)
+        ArubaPath.new(value).relative?
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/aruba/creators/aruba_file_creator.rb

@@ -0,0 +1,32 @@
+module Aruba
+  # Create things to make aruba work
+  module Creators
+    # Normal File Creator
+    # This class is not meant to be used directly by users.
+    class ArubaFileCreator
+      # Write File
+      #
+      # @param [String] path
+      #   The path to write content to
+      #
+      # @param [Object] content
+      #   The content of the file
+      #
+      # @param [TrueClass, FalseClass] check_presence (false)
+      #   Check if file exist
+      def write(path, content, check_presence = false)
+        fail "Expected #{path} to be present" if check_presence && !Aruba::Platform.file?(path)
+
+        Aruba::Platform.mkdir(File.dirname(path))
+
+        if RUBY_VERSION < '1.9'
+          File.open(path, 'w') { |f| f << content }
+        else
+          File.write(path, content)
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/aruba/creators/aruba_fixed_size_file_creator.rb

@@ -0,0 +1,32 @@
+module Aruba
+  # Create things to make aruba work
+  module Creators
+    # Create files with fixed size
+    #
+    # This class is not meant to be used directly by users.
+    #
+    # It uses a single null byte as content and really creates so called sparse
+    # files.
+    class ArubaFixedSizeFileCreator
+      # Write File
+      #
+      # @param [String] path
+      #   The path to write content to
+      #
+      # @param [Numeric] size
+      #   The size of the file
+      #
+      # @param [TrueClass, FalseClass] check_presence (false)
+      #   Check if file exist
+      def write(path, size, check_presence)
+        fail "Expected #{path} to be present" if check_presence && !Aruba::Platform.file?(path)
+
+        Aruba::Platform.mkdir(File.dirname(path))
+
+        File.open(path, "wb"){ |f| f.seek(size - 1); f.write("\0") }
+
+        self
+      end
+    end
+  end
+end

data/lib/aruba/cucumber.rb

@@ -1,21 +1,21 @@
 require 'aruba/api'
+World(Aruba::Api)
+
 require 'aruba/cucumber/hooks'
 require 'aruba/reporting'
 
-World(Aruba::Api)
-
 Given /the default aruba timeout is (\d+) seconds/ do |seconds|
-  @aruba_timeout_seconds = seconds.to_i
+  aruba.config.exit_timeout = seconds.to_i
 end
 
 Given /I use (?:a|the) fixture(?: named)? "([^"]*)"/ do |name|
-  copy File.join(Aruba::Api::FIXTURES_PATH_PREFIX, name), name
+  copy File.join(aruba.config.fixtures_path_prefix, name), name
   cd name
 end
 
 Given /The default aruba timeout is (\d+) seconds/ do |seconds|
   warn(%{\e[35m    The  /^The default aruba timeout is (\d+) seconds/ step definition is deprecated. Please use the one with `the` and not `The` at the beginning.\e[0m})
-  @aruba_timeout_seconds = seconds.to_i
+  aruba.config.exit_timeout = seconds.to_i
 end
 
 Given /^I'm using a clean gemset "([^"]*)"$/ do |gemset|
@@ -23,12 +23,12 @@ Given /^I'm using a clean gemset "([^"]*)"$/ do |gemset|
 end
 
 Given /^(?:a|the) directory(?: named)? "([^"]*)"$/ do |dir_name|
-  create_dir(dir_name)
+  create_directory(dir_name)
 end
 
 Given /^(?:a|the) directory(?: named)? "([^"]*)" with mode "([^"]*)"$/ do |dir_name, dir_mode|
-  create_dir(dir_name)
-  filesystem_permissions(dir_mode, dir_name)
+  create_directory(dir_name)
+  chmod(dir_mode, dir_name)
 end
 
 Given /^(?:a|the) file(?: named)? "([^"]*)" with:$/ do |file_name, file_content|
@@ -37,7 +37,7 @@ end
 
 Given /^(?:a|the) file(?: named)? "([^"]*)" with mode "([^"]*)" and with:$/ do |file_name, file_mode, file_content|
   write_file(file_name, file_content)
-  filesystem_permissions(file_mode, file_name)
+  chmod(file_mode, file_name)
 end
 
 Given /^(?:a|the) (\d+) byte file(?: named)? "([^"]*)"$/ do |file_size, file_name|
@@ -50,15 +50,15 @@ end
 
 Given /^(?:an|the) empty file(?: named)? "([^"]*)" with mode "([^"]*)"$/ do |file_name, file_mode|
   write_file(file_name, "")
-  filesystem_permissions(file_mode, file_name)
+  chmod(file_mode, file_name)
 end
 
 Given /^a mocked home directory$/ do
-  set_env 'HOME', File.expand_path(current_dir)
+  set_environment_variable 'HOME', expand_path('.')
 end
 
 Given /^(?:a|the) directory(?: named)? "([^"]*)" does not exist$/ do |directory_name|
-  remove_directory(directory_name, force: true)
+  remove_directory(directory_name, :force => true)
 end
 
 When /^I write to "([^"]*)" with:$/ do |file_name, file_content|
@@ -82,7 +82,7 @@ When /^I remove (?:a|the) file(?: named)? "([^"]*)"$/ do |file_name|
 end
 
 Given /^(?:a|the) file(?: named)? "([^"]*)" does not exist$/ do |file_name|
-  remove_file(file_name, force: true)
+  remove_file(file_name, :force => true)
 end
 
 When(/^I remove (?:a|the) directory(?: named)? "(.*?)"$/) do |directory_name|
@@ -98,37 +98,37 @@ Given /^I set the environment variables to:/ do |table|
     variable = row['variable'].to_s.upcase
     value = row['value'].to_s
 
-    set_env(variable, value)
+    set_environment_variable(variable, value)
   end
 end
 
 Given /^I append the value to the environment variable:/ do |table|
   table.hashes.each do |row|
     variable = row['variable'].to_s.upcase
-    value = row['value'].to_s + row['value'].to_s
+    value = row['value'].to_s
 
-    set_env(variable, value)
+    append_environment_variable(variable, value)
   end
 end
 
 When /^I run "(.*)"$/ do |cmd|
   warn(%{\e[35m    The /^I run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
-  run_simple(unescape(cmd), false)
+  run_simple(Aruba::Platform.unescape(cmd, aruba.config.keep_ansi), false)
 end
 
 When /^I run `([^`]*)`$/ do |cmd|
-  run_simple(unescape(cmd), false)
+  run_simple(Aruba::Platform.unescape(cmd, aruba.config.keep_ansi), false)
 end
 
 When /^I successfully run "(.*)"$/ do |cmd|
   warn(%{\e[35m    The  /^I successfully run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
-  run_simple(unescape(cmd))
+  run_simple(Aruba::Platform.unescape(cmd, aruba.config.keep_ansi))
 end
 
 ## I successfully run `echo -n "Hello"`
 ## I successfully run `sleep 29` for up to 30 seconds
 When /^I successfully run `(.*?)`(?: for up to (\d+) seconds)?$/ do |cmd, secs|
-  run_simple(unescape(cmd), true, secs && secs.to_i)
+  run_simple(Aruba::Platform.unescape(cmd, aruba.config.keep_ansi), true, secs && secs.to_i)
 end
 
 When /^I run "([^"]*)" interactively$/ do |cmd|
@@ -137,7 +137,7 @@ When /^I run "([^"]*)" interactively$/ do |cmd|
 end
 
 When /^I run `([^`]*)` interactively$/ do |cmd|
-  @interactive = run(unescape(cmd))
+  @interactive = run(Aruba::Platform.unescape(cmd, aruba.config.keep_ansi))
 end
 
 When /^I type "([^"]*)"$/ do |input|
@@ -318,68 +318,102 @@ Then /^the stderr from "([^"]*)" should not contain "([^"]*)"$/ do |cmd, unexpec
   assert_no_partial_output(unexpected, stderr_from(cmd))
 end
 
-Then /^the following files should (not )?exist:$/ do |expect_match, files|
-  files.raw.each do |row|
-    if expect_match
-      expect(row[0]).not_to be_existing_file
-    else
-      expect(row[0]).to be_existing_file
-    end
+Then /^the following files should (not )?exist:$/ do |negated, files|
+  files = files.rows.flatten
+
+  if negated
+    expect(files).not_to include an_existing_file
+  else
+    expect(files).to all be_an_existing_file
   end
 end
 
 Then /^(?:a|the) file(?: named)? "([^"]*)" should (not )?exist$/ do |file, expect_match|
   if expect_match
-    expect(file).not_to be_existing_file
+    expect(file).not_to be_an_existing_file
   else
-    expect(file).to be_existing_file
+    expect(file).to be_an_existing_file
   end
 end
 
 Then /^(?:a|the) file matching %r<(.*?)> should (not )?exist$/ do |pattern, expect_match|
   if expect_match
-    expect(all_paths).not_to match_path_pattern(Regexp.new(pattern))
+    expect(all_paths).not_to include match Regexp.new(pattern)
   else
-    expect(all_paths).to match_path_pattern(Regexp.new(pattern))
+    expect(all_paths).to include match Regexp.new(pattern)
   end
 end
 
-Then /^(?:a|the) (\d+) byte file(?: named)? "([^"]*)" should exist$/ do |file_size, file_name|
-  check_file_size([[file_name, file_size.to_i]])
+Then /^(?:a|the) (\d+) byte file(?: named)? "([^"]*)" should (not )?exist$/ do |size, file, negated|
+  if negated
+    expect(file).not_to have_file_size(size)
+  else
+    expect(file).to have_file_size(size)
+  end
 end
 
-Then /^the following directories should (not )?exist:$/ do |expect_match, directories|
-  check_directory_presence(directories.raw.map{|directory_row| directory_row[0]}, !expect_match)
-end
+Then /^the following directories should (not )?exist:$/ do |negated, directories|
+  directories = directories.rows.flatten
 
-Then /^(?:a|the) directory(?: named)? "([^"]*)" should (not )?exist$/ do |directory, expect_match|
-  check_directory_presence([directory], !expect_match)
+  if negated
+    expect(directories).not_to include an_existing_directory
+  else
+    expect(directories).to all be_an_existing_directory
+  end
 end
 
-Then /^(?:a|the) file "([^"]*)" should (not )?contain "([^"]*)"$/ do |file, expect_match, partial_content|
-  check_file_content(file, Regexp.compile(Regexp.escape(partial_content)), !expect_match)
+Then /^(?:a|the) directory(?: named)? "([^"]*)" should (not )?exist$/ do |directory, negated|
+  if negated
+    expect(directory).not_to be_an_existing_directory
+  else
+    expect(directory).to be_an_existing_directory
+  end
 end
 
-Then /^(?:a|the) file "([^"]*)" should (not )?contain:$/ do |file, expect_match, partial_content|
-  check_file_content(file, Regexp.compile(Regexp.escape(partial_content)), !expect_match)
+Then /^(?:a|the) file "([^"]*)" should (not )?contain "([^"]*)"$/ do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(content)
+  else
+    expect(file).to have_file_content Regexp.new(content)
+  end
 end
 
-Then /^(?:a|the) file "([^"]*)" should (not )?contain exactly:$/ do |file, expect_match, exact_content|
-  check_file_content(file, exact_content, !expect_match)
+Then /^(?:a|the) file "([^"]*)" should (not )?contain:$/ do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(content.chomp)
+  else
+    expect(file).to have_file_content Regexp.new(content.chomp)
+  end
 end
 
-Then /^(?:a|the) file "([^"]*)" should (not )?match \/([^\/]*)\/$/ do |file, expect_match, partial_content|
-  check_file_content(file, /#{partial_content}/, !expect_match)
+Then /^(?:a|the) file "([^"]*)" should (not )?contain exactly:$/ do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content content
+  else
+    expect(file).to have_file_content content
+  end
 end
 
-Then /^(?:a|the) file "([^"]*)" should (not )?be equal to file "([^"]*)"/ do |file, expect_match, reference_file|
-  check_binary_file_content(file, reference_file, !expect_match)
+Then /^(?:a|the) file "([^"]*)" should (not )?match \/([^\/]*)\/$/ do |file, negated, content|
+  if negated
+    expect(file).not_to have_file_content Regexp.new(content)
+  else
+    expect(file).to have_file_content Regexp.new(content)
+  end
 end
 
-Then /^the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)"$/ do |file, expect_match, mode|
-  check_filesystem_permissions(mode, file, !expect_match)
+Then /^(?:a|the) file "([^"]*)" should (not )?be equal to file "([^"]*)"/ do |file, negated, reference_file|
+  if negated
+    expect(file).not_to have_same_file_content_like(reference_file)
+  else
+    expect(file).to have_same_file_content_like(reference_file)
+  end
 end
 
-Before '@mocked_home_directory' do
-  set_env 'HOME', expand_path('.')
+Then /^the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)"$/ do |file, negated, permissions|
+  if negated
+    expect(file).not_to have_permissions(permissions)
+  else
+    expect(file).to have_permissions(permissions)
+  end
 end