aruba 1.0.0.pre.alpha.2 → 1.0.1

data/lib/aruba/basic_configuration.rb

@@ -32,8 +32,8 @@ module Aruba
         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?
+        raise ArgumentError, 'Either use block or default value' if block_given? && default
+        raise ArgumentError, 'contract-options is required' if contract.nil?
 
         Contract contract
         add_option(name, block_given? ? yield(InConfigWrapper.new(known_options)) : default)
@@ -61,9 +61,8 @@ module Aruba
         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.to_s.empty?
-        fail ArgumentError, 'contract-options is required' if contract.nil?
+        raise ArgumentError, 'Either use block or default value' if block_given? && default
+        raise ArgumentError, 'contract-options is required' if contract.nil?
 
         # Add writer
         add_option(name, block_given? ? yield(InConfigWrapper.new(known_options)) : default)
@@ -72,7 +71,7 @@ module Aruba
         define_method("#{name}=") { |v| find_option(name).value = v }
 
         # Add reader
-        option_reader name, :contract => { None => contract.values.first }
+        option_reader name, contract: { None => contract.values.first }
       end
 
       private
@@ -80,7 +79,7 @@ module Aruba
       def add_option(name, value = nil)
         return if known_options.key?(name)
 
-        known_options[name] = Option.new(:name => name, :value => value)
+        known_options[name] = Option.new(name: name, value: value)
 
         self
       end
@@ -114,29 +113,13 @@ module Aruba
 
     # Make deep dup copy of configuration
     def make_copy
-      obj = self.dup
+      obj = 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
@@ -226,7 +209,7 @@ module Aruba
     end
 
     def find_option(name)
-      fail NotImplementedError, %(Unknown option "#{name}") unless option? name
+      raise NotImplementedError, %(Unknown option "#{name}") unless option? name
 
       local_options[name]
     end

data/lib/aruba/basic_configuration/option.rb

@@ -15,8 +15,8 @@ module Aruba
         name = opts[:name]
         value = opts[:value]
 
-        fail ArgumentError, '"name" is required' unless opts.key? :name
-        fail ArgumentError, '"value" is required' unless opts.key? :value
+        raise ArgumentError, '"name" is required' unless opts.key? :name
+        raise ArgumentError, '"value" is required' unless opts.key? :value
 
         @name          = name
         @value         = value

data/lib/aruba/cli.rb

@@ -18,7 +18,10 @@ module Aruba
     end
 
     desc 'init', 'Initialize aruba'
-    option :test_framework, :default => 'cucumber', :enum => %w(cucumber rspec minitest), :desc => 'Choose which test framework to use'
+    option :test_framework,
+           default: 'cucumber',
+           enum: %w(cucumber rspec minitest),
+           desc: 'Choose which test framework to use'
     def init
       Aruba::Initializer.new.call(options[:test_framework])
     end

data/lib/aruba/colorizer.rb

@@ -1,108 +1,19 @@
+# Aruba
 module Aruba
-  # The ANSIColor module can be used for namespacing and mixed into your own
-  # classes.
-  module AnsiColor
-    # :stopdoc:
-    ATTRIBUTES = [
-      [ :clear        ,   0 ],
-      [ :reset        ,   0 ],     # synonym for :clear
-      [ :bold         ,   1 ],
-      [ :dark         ,   2 ],
-      [ :italic       ,   3 ],     # not widely implemented
-      [ :underline    ,   4 ],
-      [ :underscore   ,   4 ],     # synonym for :underline
-      [ :blink        ,   5 ],
-      [ :rapid_blink  ,   6 ],     # not widely implemented
-      [ :negative     ,   7 ],     # no reverse because of String#reverse
-      [ :concealed    ,   8 ],
-      [ :strikethrough,   9 ],     # not widely implemented
-      [ :black        ,  30 ],
-      [ :red          ,  31 ],
-      [ :green        ,  32 ],
-      [ :yellow       ,  33 ],
-      [ :blue         ,  34 ],
-      [ :magenta      ,  35 ],
-      [ :cyan         ,  36 ],
-      [ :white        ,  37 ],
-      [ :on_black     ,  40 ],
-      [ :on_red       ,  41 ],
-      [ :on_green     ,  42 ],
-      [ :on_yellow    ,  43 ],
-      [ :on_blue      ,  44 ],
-      [ :on_magenta   ,  45 ],
-      [ :on_cyan      ,  46 ],
-      [ :on_white     ,  47 ]
-    ].freeze
-
-    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
-    # :startdoc:
-
-    # Returns true, if the coloring function of this module
-    # is switched on, false otherwise.
-    def self.coloring?
-      @coloring
-    end
-
-    # Turns the coloring on or off globally, so you can easily do
-    # this for example:
-    #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
-    def self.coloring=(val)
-      @coloring = val
-    end
-    self.coloring = true
-
-    ATTRIBUTES.each do |c, v|
-      define_method(c) do |string|
-        result = ''
-        result << "\e[#{v}m" if Aruba::AnsiColor.coloring?
-        if block_given?
-          result << yield
-        elsif string
-          result << string
-        elsif respond_to?(:to_str)
-          result << to_str
-        else
-          return result #only switch on
-        end
-        result << "\e[0m" if Aruba::AnsiColor.coloring?
-        result
-      end
-    end
-
-    # Regular expression that is used to scan for ANSI-sequences while
-    # uncoloring strings.
-    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+  # Simple colorizer class. Only supports the color cyan
+  class Colorizer
+    class << self
+      attr_accessor :coloring
 
-    def self.included(klass)
-      if klass == String
-        ATTRIBUTES.delete(:clear)
-        ATTRIBUTE_NAMES.delete(:clear)
-      end
+      alias coloring? coloring
     end
 
-    # Returns an uncolored version of the string, that is all
-    # ANSI-sequences are stripped from the string.
-    def uncolored(string = nil) # :yields:
-      if block_given?
-        yield.gsub(COLORED_REGEXP, '')
-      elsif string
-        string.gsub(COLORED_REGEXP, '')
-      elsif respond_to?(:to_str)
-        to_str.gsub(COLORED_REGEXP, '')
+    def cyan(string)
+      if self.class.coloring?
+        "\e[36m#{string}\e[0m"
       else
-        ''
+        string
       end
     end
-
-    # Returns an array of all Aruba::Platforms::AnsiColor attributes as symbols.
-    def attributes
-      ATTRIBUTE_NAMES
-    end
-  end
-end
-
-module Aruba
-  class Colorizer
-    include Aruba::AnsiColor
   end
 end

data/lib/aruba/command.rb

@@ -48,6 +48,8 @@ module Aruba
 
     # Stop command
     def stop(*)
+      return if __getobj__.stopped?
+
       __getobj__.stop
       event_bus.notify Events::CommandStopped.new(self)
 
@@ -56,6 +58,8 @@ module Aruba
 
     # Terminate command
     def terminate(*)
+      return if __getobj__.stopped?
+
       __getobj__.terminate
       event_bus.notify Events::CommandStopped.new(self)
 

data/lib/aruba/config/jruby.rb

@@ -2,16 +2,26 @@ require 'rbconfig'
 
 # ideas taken from: http://blog.headius.com/2010/03/jruby-startup-time-tips.html
 Aruba.configure do |config|
-  config.before :command do
+  config.before :command do |command|
     next unless RUBY_PLATFORM == 'java'
 
+    env = command.environment
+
+    jruby_opts = env['JRUBY_OPTS'] || ''
+
     # disable JIT since these processes are so short lived
-    ENV['JRUBY_OPTS'] = "-X-C #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '') .include? '-X-C'
+    jruby_opts = "-X-C #{jruby_opts}" unless jruby_opts.include? '-X-C'
 
     # Faster startup for jruby
-    ENV['JRUBY_OPTS'] = "--dev #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '').include? '--dev'
+    jruby_opts = "--dev #{jruby_opts}" unless jruby_opts.include? '--dev'
+
+    env['JRUBY_OPTS'] = jruby_opts
+
+    if /solaris|sunos/i.match?(RbConfig::CONFIG['host_os'])
+      java_opts = env['JAVA_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 && !(ENV['JAVA_OPTS'] || '').include?('-d32')
+      # force jRuby to use client JVM for faster startup times
+      env['JAVA_OPTS'] = "-d32 #{java_opts}" unless java_opts.include?('-d32')
+    end
   end
 end

data/lib/aruba/config_wrapper.rb

@@ -30,9 +30,11 @@ module Aruba
     # If one method ends with "=", e.g. ":option1=", then notify the event
     # queue, that the user changes the value of "option1"
     def method_missing(name, *args, &block)
-      event_bus.notify Events::ChangedConfiguration.new(:changed => { :name => name.to_s.gsub(/=$/, ''), :value => args.first }) if name.to_s.end_with? '='
+      notify(name, args) if name.to_s.end_with?('=')
 
-      config.send(name, *args, &block)
+      return config.send(name, *args, &block) if config.respond_to? name
+
+      super
     end
 
     # Pass on respond_to?-calls
@@ -54,5 +56,18 @@ module Aruba
     def respond_to?(m)
       config.respond_to? m
     end
+
+    private
+
+    def notify(name, args)
+      event_bus.notify(
+        Events::ChangedConfiguration.new(
+          changed: {
+            name: name.to_s.gsub(/=$/, ''),
+            value: args.first
+          }
+        )
+      )
+    end
   end
 end

data/lib/aruba/configuration.rb

@@ -0,0 +1,107 @@
+require 'contracts'
+
+require 'aruba/version'
+require 'aruba/basic_configuration'
+require 'aruba/in_config_wrapper'
+require 'aruba/hooks'
+
+require 'aruba/contracts/relative_path'
+require 'aruba/contracts/absolute_path'
+require 'aruba/contracts/enum'
+
+require 'aruba/contracts/is_power_of_two'
+
+# Aruba
+module Aruba
+  # Aruba Configuration
+  #
+  # This defines the configuration options of aruba
+  class Configuration < BasicConfiguration
+    option_reader :root_directory, contract: { None => String }, default: Dir.getwd
+
+    option_accessor :working_directory,
+                    contract: { Aruba::Contracts::RelativePath =>
+                                Aruba::Contracts::RelativePath },
+                    default: 'tmp/aruba'
+
+    option_reader :fixtures_path_prefix, contract: { None => String }, default: '%'
+
+    option_accessor :exit_timeout, contract: { Num => Num }, default: 15
+    option_accessor :stop_signal, contract: { Maybe[String] => Maybe[String] }, default: nil
+    option_accessor :io_wait_timeout, contract: { Num => Num }, default: 0.1
+    option_accessor :startup_wait_time, contract: { Num => Num }, default: 0
+    option_accessor :fixtures_directories,
+                    contract: { Array => ArrayOf[String] },
+                    default: %w(features/fixtures spec/fixtures test/fixtures fixtures)
+
+    option_accessor :command_runtime_environment, contract: { Hash => Hash }, default: {}
+    option_accessor :command_search_paths,
+                    contract: { ArrayOf[String] => ArrayOf[String] } do |config|
+                      [File.join(config.root_directory.value, 'bin'),
+                       File.join(config.root_directory.value, 'exe')]
+                    end
+    option_accessor :remove_ansi_escape_sequences, contract: { Bool => Bool }, default: true
+    option_accessor :command_launcher,
+                    contract: {
+                      Aruba::Contracts::Enum[:in_process, :spawn, :debug] =>
+                        Aruba::Contracts::Enum[:in_process, :spawn, :debug]
+                    },
+                    default: :spawn
+    option_accessor :main_class, contract: { Class => Maybe[Class] }, default: nil
+
+    option_accessor :home_directory,
+                    contract: {
+                      Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] =>
+                        Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath]
+                    } do |config|
+                      File.join(config.root_directory.value, config.working_directory.value)
+                    end
+
+    option_accessor :log_level,
+                    contract: {
+                      Aruba::Contracts::Enum[:fatal, :warn, :debug, :info,
+                                             :error, :unknown, :silent] =>
+                        Aruba::Contracts::Enum[:fatal, :warn, :debug, :info,
+                                               :error, :unknown, :silent]
+                    },
+                    default: :info
+
+    # TODO: deprecate this value and replace with "filesystem allocation unit"
+    # equal to 4096 by default. "filesystem allocation unit" would represent
+    # the actual MINIMUM space taken in bytes by a 1-byte file
+    option_accessor :physical_block_size,
+                    contract: { Aruba::Contracts::IsPowerOfTwo =>
+                                Aruba::Contracts::IsPowerOfTwo },
+                    default: 512
+    option_accessor :console_history_file, contract: { String => String },
+                                           default: '~/.aruba_history'
+
+    option_accessor :activate_announcer_on_command_failure,
+                    contract: { ArrayOf[Symbol] => ArrayOf[Symbol] },
+                    default: []
+    option_accessor :allow_absolute_paths, contract: { Bool => Bool }, default: false
+  end
+end
+
+# Aruba
+module Aruba
+  @config = Configuration.new
+
+  class << self
+    attr_reader :config
+
+    # Configure aruba
+    #
+    # @example How to configure aruba
+    #
+    #   Aruba.configure do |config|
+    #     config.<option> = <value>
+    #   end
+    #
+    def configure(&block)
+      @config.configure(&block)
+
+      self
+    end
+  end
+end

data/lib/aruba/console.rb

@@ -9,7 +9,6 @@ module Aruba
   class Console
     # Start the aruba console
     #
-    # rubocop:disable Metrics/MethodLength
     def start
       # Start IRB with current context:
       # http://stackoverflow.com/questions/4189818/how-to-run-irb-start-in-context-of-current-class
@@ -20,10 +19,10 @@ module Aruba
 
       IRB.conf[:PROMPT] = {}
       IRB.conf[:PROMPT][:ARUBA] = {
-        :PROMPT_I => '%N:%03n:%i> ',
-        :PROMPT_S => '%N:%03n:%i%l ',
-        :PROMPT_C => '%N:%03n:%i* ',
-        :RETURN => "# => %s\n"
+        PROMPT_I: '%N:%03n:%i> ',
+        PROMPT_S: '%N:%03n:%i%l ',
+        PROMPT_C: '%N:%03n:%i* ',
+        RETURN: "# => %s\n"
       }
       IRB.conf[:PROMPT_MODE] = :ARUBA
 
@@ -51,7 +50,7 @@ module Aruba
       irb = IRB::Irb.new(IRB::WorkSpace.new(context.new))
       IRB.conf[:MAIN_CONTEXT] = irb.context
 
-      trap("SIGINT") do
+      trap('SIGINT') do
         irb.signal_handle
       end
 
@@ -63,6 +62,5 @@ module Aruba
         IRB.irb_at_exit
       end
     end
-    # rubocop:enable Metrics/MethodLength
   end
 end