aruba-win-fix 0.14.2

data/lib/aruba/basic_configuration/option.rb

@@ -0,0 +1,32 @@
+# Aruba
+module Aruba
+  # Basic Configuration
+  #
+  class BasicConfiguration
+    # A configuration option
+    #
+    # @private
+    class Option
+      attr_accessor :name, :value
+      attr_reader :default_value
+
+      # Create option
+      def initialize(opts = {})
+        name = opts[:name]
+        value = opts[:value]
+
+        fail ArgumentError, '"name" is required' unless opts.key? :name
+        fail ArgumentError, '"value" is required' unless opts.key? :value
+
+        @name          = name
+        @value         = value
+        @default_value = value
+      end
+
+      # Compare option
+      def ==(other)
+        name == other.name && value == other.value
+      end
+    end
+  end
+end

data/lib/aruba/cli.rb

@@ -0,0 +1,26 @@
+require 'thor'
+require 'aruba/console'
+require 'aruba/initializer'
+
+# Aruba
+module Aruba
+  # Command line Interface
+  #
+  # @private
+  class Cli < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc 'console', "Start aruba's console"
+    def console
+      Aruba::Console.new.start
+    end
+
+    desc 'init', 'Initialize aruba'
+    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
+  end
+end

data/lib/aruba/colorizer.rb

@@ -0,0 +1,108 @@
+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/
+
+    def self.included(klass)
+      if klass == String
+        ATTRIBUTES.delete(:clear)
+        ATTRIBUTE_NAMES.delete(:clear)
+      end
+    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, '')
+      else
+        ''
+      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

@@ -0,0 +1,74 @@
+require 'delegate'
+require 'aruba/processes/spawn_process'
+require 'aruba/processes/in_process'
+require 'aruba/processes/debug_process'
+
+# Aruba
+module Aruba
+  # Command
+  #
+  # This class is not meant for direct use - Command.new, though it's API is
+  # public. As it is just a wrapper class, have a look at `BasicProcess` and
+  # the like for the public API.
+  #
+  # @see BasicProcess
+  # @see SpawnProcess
+  #
+  # @private
+  class Command < SimpleDelegator
+    private
+
+    attr_reader :event_bus
+
+    public
+
+    def initialize(command, opts = {})
+      launchers = []
+      launchers << Processes::DebugProcess
+      launchers << Processes::InProcess
+      launchers << Processes::SpawnProcess
+
+      launcher = launchers.find { |l| l.match? opts[:mode] }
+
+      super launcher.new(
+        command,
+        opts.fetch(:exit_timeout),
+        opts.fetch(:io_wait_timeout),
+        opts.fetch(:working_directory),
+        opts.fetch(:environment),
+        opts.fetch(:main_class),
+        opts.fetch(:stop_signal),
+        opts.fetch(:startup_wait_time)
+      )
+
+      @event_bus = opts.fetch(:event_bus)
+    rescue KeyError => e
+      raise ArgumentError, e.message
+    end
+
+    # Stop command
+    def stop(*)
+      __getobj__.stop
+      event_bus.notify Events::CommandStopped.new(self)
+
+      self
+    end
+
+    # Terminate command
+    def terminate(*)
+      __getobj__.terminate
+      event_bus.notify Events::CommandStopped.new(self)
+
+      self
+    end
+
+    # Start command
+    def start
+      __getobj__.start
+      event_bus.notify Events::CommandStarted.new(self)
+
+      self
+    end
+    alias run! start
+  end
+end

data/lib/aruba/config.rb

@@ -0,0 +1,108 @@
+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
+    if Aruba::VERSION >= '1.0.0'
+      option_reader :root_directory, :contract => { None => String }, :default => Dir.getwd
+    else
+      option_accessor :root_directory, :contract => { String => String }, :default => Dir.getwd
+    end
+
+    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
+
+    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 => ENV.to_hash
+    # rubocop:disable Metrics/LineLength
+    option_accessor(:command_search_paths, :contract => { ArrayOf[String] => ArrayOf[String] }) { |config| [File.join(config.root_directory.value, 'bin'), File.join(config.root_directory.value, 'exe')] }
+    # rubocop:enable Metrics/LineLength
+    option_accessor :keep_ansi, :contract => { Bool => Bool }, :default => false
+    option_accessor :remove_ansi_escape_sequences, :contract => { Bool => Bool }, :default => true
+    # rubocop:disable Metrics/LineLength
+    option_accessor :command_launcher, :contract => { Aruba::Contracts::Enum[:in_process, :spawn, :debug] => Aruba::Contracts::Enum[:in_process, :spawn, :debug] }, :default => :spawn
+    # rubocop:enable Metrics/LineLength
+    option_accessor :main_class, :contract => { Class => Maybe[Class] }, :default => nil
+    # rubocop:disable Metrics/LineLength
+
+    # rubocop:disable Metrics/LineLength
+    if Aruba::VERSION >= '1.0.0'
+      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
+    else
+      option_accessor :home_directory, :contract => { Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] => Or[Aruba::Contracts::AbsolutePath, Aruba::Contracts::RelativePath] }, :default => ENV['HOME']
+    end
+    # rubocop:enable Metrics/LineLength
+
+    # rubocop:disable Metrics/LineLength
+    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
+    # rubocop:enable Metrics/LineLength
+
+    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 => []
+  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
+
+# Aruba
+module Aruba
+  # Old Config
+  #
+  # @private
+  # @deprecated
+  class Config < Configuration
+    def initialize(*args)
+      warn('The use of "Aruba::Config" is deprecated. Use "Aruba::Configuration" instead.')
+
+      super
+    end
+  end
+end

data/lib/aruba/config/jruby.rb

@@ -0,0 +1,17 @@
+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']}" unless (ENV['JRUBY_OPTS'] || '') .include? '-X-C'
+
+    # Faster startup for jruby
+    ENV['JRUBY_OPTS'] = "--dev #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '').include? '--dev'
+
+    # 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')
+  end
+end

data/lib/aruba/config_wrapper.rb

@@ -0,0 +1,58 @@
+module Aruba
+  # This wraps the current runtime configuration of aruba.
+  # If an option is changed, it notifies the event queue.
+  #
+  # This class is not meant for direct use - ConfigWrapper.new - by normal
+  # users.
+  #
+  # @private
+  class ConfigWrapper
+    private
+
+    attr_reader :config, :event_bus
+
+    public
+
+    # Create proxy
+    #
+    # @param [Config] config
+    #   An aruba config object.
+    #
+    # @param [#notify] event_bus
+    #   The event queue which should be notified.
+    def initialize(config, event_bus)
+      @config = config
+      @event_bus = event_bus
+    end
+
+    # Proxy all methods
+    #
+    # 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? '='
+
+      config.send(name, *args, &block)
+    end
+
+    # Pass on respond_to?-calls
+    def respond_to_missing?(name, _include_private)
+      config.respond_to? name
+    end
+
+    # Compare two configs
+    #
+    # The comparism is done based on their values. No hooks are compared.
+    #
+    # Somehow `#respond_to_missing?`, `method_missing?` and `respond_to?` don't
+    # help here.
+    def ==(other)
+      config == other
+    end
+
+    # Pass on respond_to?-calls
+    def respond_to?(m)
+      config.respond_to? m
+    end
+  end
+end

data/lib/aruba/console.rb

@@ -0,0 +1,70 @@
+require 'irb'
+
+require 'aruba/api'
+require 'aruba/console/help'
+
+# Aruba
+module Aruba
+  # Consule
+  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
+      ARGV.clear
+      IRB.setup nil
+
+      IRB.conf[:IRB_NAME] = '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"
+      }
+      IRB.conf[:PROMPT_MODE] = :ARUBA
+
+      IRB.conf[:RC] = false
+
+      require 'irb/completion'
+      require 'irb/ext/save-history'
+      IRB.conf[:READLINE] = true
+      IRB.conf[:SAVE_HISTORY] = 1000
+      IRB.conf[:HISTORY_FILE] = Aruba.config.console_history_file
+
+      # rubocop:disable Lint/NestedMethodDefinition
+      context = Class.new do
+        include Aruba::Api
+        include Aruba::Console::Help
+
+        def initialize
+          setup_aruba
+        end
+
+        def inspect
+          'nil'
+        end
+      end
+      # rubocop:enable Lint/NestedMethodDefinition
+
+      irb = IRB::Irb.new(IRB::WorkSpace.new(context.new))
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+
+      trap("SIGINT") do
+        irb.signal_handle
+      end
+
+      begin
+        catch(:IRB_EXIT) do
+          irb.eval_input
+        end
+      ensure
+        IRB.irb_at_exit
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end