aruba 1.0.0.pre.alpha.2 → 1.0.0.pre.alpha.3

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_wrapper.rb

@@ -30,7 +30,7 @@ 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? '='
+      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

data/lib/aruba/configuration.rb

@@ -0,0 +1,78 @@
+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: {}
+    # 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 :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
+    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

@@ -20,10 +20,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 +51,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
 

data/lib/aruba/console/help.rb

@@ -18,7 +18,7 @@ module Aruba
 
       # List available methods in aruba
       def aruba_methods
-        ms = (Aruba::Api.instance_methods - Module.instance_methods).each_with_object([]) { |e, a| a << format("* %s", e) }.sort
+        ms = (Aruba::Api.instance_methods - Module.instance_methods).each_with_object([]) { |e, a| a << format('* %s', e) }.sort
 
         puts "Available Methods:\n" + ms.join("\n")
 

data/lib/aruba/cucumber.rb

@@ -8,4 +8,3 @@ require 'aruba/cucumber/command'
 require 'aruba/cucumber/environment'
 require 'aruba/cucumber/file'
 require 'aruba/cucumber/testing_frameworks'
-require 'aruba/cucumber/rvm'

data/lib/aruba/cucumber/command.rb

@@ -1,55 +1,34 @@
 require 'aruba/generators/script_file'
 
-When(/^I run "(.*)"$/)do |cmd|
-  warn(%{\e[35m    The /^I run "(.*)"$/ step definition is deprecated. Please use the `backticks` version\e[0m})
-
-  cmd = sanitize_text(cmd)
-  run_command_and_stop(cmd, false)
-end
-
-When(/^I run `([^`]*)`$/)do |cmd|
+When(/^I run `([^`]*)`$/) do |cmd|
   cmd = sanitize_text(cmd)
-  run_command_and_stop(cmd, :fail_on_error => 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})
-
-  cmd = sanitize_text(cmd)
-  run_command_and_stop(cmd)
+  run_command_and_stop(cmd, fail_on_error: false)
 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|
+When(/^I successfully run `(.*?)`(?: for up to ([\d.]+) seconds)?$/) do |cmd, secs|
   cmd = sanitize_text(cmd)
-  run_command_and_stop(cmd, :fail_on_error => true, :exit_timeout => secs && secs.to_i)
+  run_command_and_stop(cmd, fail_on_error: true, exit_timeout: secs && secs.to_f)
 end
 
 When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) do |shell, commands|
-  prepend_environment_variable('PATH', expand_path('bin') + File::PATH_SEPARATOR)
+  full_path = expand_path('bin/myscript')
 
   Aruba.platform.mkdir(expand_path('bin'))
   shell ||= Aruba.platform.default_shell
 
-  Aruba::ScriptFile.new(:interpreter => shell, :content => commands,
-                        :path => expand_path('bin/myscript')).call
-  step 'I run `myscript`'
-end
-
-When(/^I run "([^"]*)" interactively$/) do |cmd|
-  Aruba.platform.deprecated(%{\e[35m    The /^I run "([^"]*)" interactively$/ step definition is deprecated. Please use the `backticks` version\e[0m})
-
-  step %(I run `#{cmd}` interactively)
+  Aruba::ScriptFile.new(interpreter: shell, content: commands, path: full_path).call
+  run_command_and_stop(Shellwords.escape(full_path), fail_on_error: false)
 end
 
-When(/^I run `([^`]*)` interactively$/)do |cmd|
+When(/^I run `([^`]*)` interactively$/) do |cmd|
   cmd = sanitize_text(cmd)
   @interactive = run_command(cmd)
 end
 
 # Merge interactive and background after refactoring with event queue
-When(/^I run `([^`]*)` in background$/)do |cmd|
+When(/^I run `([^`]*)` in background$/) do |cmd|
   run_command(sanitize_text(cmd))
 end
 
@@ -68,35 +47,26 @@ When(/^I pipe in (?:a|the) file(?: named)? "([^"]*)"$/) do |file|
 end
 
 When(/^I (terminate|stop) the command (?:"([^"]*)"|(?:started last))$/) do |signal, command|
-  if command
-    cmd = all_commands.find { |c| c.commandline == command }
-    fail ArgumentError, %(No command "#{command}" found) if cmd.nil?
+  monitor = aruba.command_monitor
 
-    if signal == 'terminate'
-      # last_command_started.terminate
-      process_monitor.terminate_process!(process_monitor.get_process(command))
-    else
-      # last_command_started.stop
-      process_monitor.stop_process(process_monitor.get_process(command))
-    end
+  cmd = if command
+          monitor.find(command)
+        else
+          last_command_started
+        end
+
+  if signal == 'terminate'
+    cmd.terminate
   else
-    if signal == 'terminate'
-      # last_command_started.terminate
-      process_monitor.terminate_process!(last_command_started)
-    else
-      # last_command_started.stop
-      process_monitor.stop_process(last_command_started)
-    end
+    cmd.stop
   end
 end
 
 When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$/) do |channel, expected|
-  fail %(Invalid output channel "#{channel}" chosen. Please choose one of "output, stdout or stderr") unless %w(output stdout stderr).include? channel
-
   begin
     Timeout.timeout(aruba.config.exit_timeout) do
       loop do
-        output = last_command_started.public_send channel.to_sym, :wait_for_io => 0
+        output = last_command_started.public_send channel.to_sym, wait_for_io: 0
 
         output   = sanitize_text(output)
         expected = sanitize_text(expected)
@@ -146,7 +116,7 @@ When(/^I wait for (?:output|stdout) to contain "([^"]*)"$/) do |expected|
 end
 
 Then(/^the output should be (\d+) bytes long$/) do |size|
-  expect(all_output).to have_output_size size.to_i
+  expect(last_command_started.output).to have_output_size size.to_i
 end
 
 Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain( exactly)? "([^"]*)"$/) do |channel, cmd, negated, exactly, expected|
@@ -171,23 +141,10 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
                             :an_output_string_including
                           end
 
-  if Aruba::VERSION < '1.0'
-    combined_output = commands.map do |c|
-      c.stop
-      c.send(channel.to_sym).chomp
-    end.join("\n")
-
-    if negated
-      expect(combined_output).not_to send(output_string_matcher, expected)
-    else
-      expect(combined_output).to send(output_string_matcher, expected)
-    end
+  if negated
+    expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
   else
-    if negated
-      expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
-    else
-      expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
-    end
+    expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
   end
 end
 
@@ -219,23 +176,10 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
                             :an_output_string_including
                           end
 
-  if Aruba::VERSION < '1.0'
-    combined_output = commands.map do |c|
-      c.stop
-      c.send(channel.to_sym).chomp
-    end.join("\n")
-
-    if negated
-      expect(combined_output).not_to send(output_string_matcher, expected)
-    else
-      expect(combined_output).to send(output_string_matcher, expected)
-    end
+  if negated
+    expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
   else
-    if negated
-      expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
-    else
-      expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
-    end
+    expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
   end
 end
 
@@ -268,6 +212,10 @@ Then(/^the output should( not)? match:$/) do |negated, expected|
 end
 
 Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
+  if last_command_stopped.nil?
+    last_command_started.stop
+  end
+
   if negated
     expect(last_command_stopped).not_to have_exit_status exit_status.to_i
   else
@@ -276,6 +224,8 @@ Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
 end
 
 Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
@@ -290,6 +240,8 @@ Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expe
 end
 
 Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
@@ -304,6 +256,8 @@ Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
 end
 
 Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
@@ -318,6 +272,8 @@ Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, exp
 end
 
 Then(/^it should( not)? (pass|fail) (?:with regexp?|matching):$/) do |negated, pass_fail, expected|
+  last_command_started.stop
+
   if pass_fail == 'pass'
     expect(last_command_stopped).to be_successfully_executed
   else
@@ -348,16 +304,16 @@ end
 
 Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) do |channel, negated, table|
   table.raw.flatten.each do |expected|
-    matcher = case channel.to_sym
-              when :output
-                :have_output
-              when :stderr
-                :have_output_on_stderr
-              when :stdout
-                :have_output_on_stdout
-              else
-                fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
-              end
+    case channel.to_sym
+    when :output
+      :have_output
+    when :stderr
+      :have_output_on_stderr
+    when :stdout
+      :have_output_on_stdout
+    else
+      fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
+    end
 
     if negated
       expect(all_commands).not_to include_an_object have_output an_output_string_including(expected)
@@ -367,36 +323,20 @@ Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:
   end
 end
 
-Given(/the default aruba timeout is (\d+) seconds/) do |seconds|
-  # rubocop:disable Metrics/LineLength
-  Aruba.platform.deprecated(%{The /^the default aruba timeout is (\d+) seconds/ step definition is deprecated. Please use /^the default aruba exit timeout is (\d+) seconds/ step definition is deprecated.})
-  # rubocop:enable Metrics/LineLength
-
-  aruba.config.exit_timeout = seconds.to_i
-end
-
-Given(/The default aruba timeout is (\d+) seconds/) do |seconds|
-  # rubocop:disable Metrics/LineLength
-  Aruba.platform.deprecated(%{The /^The default aruba timeout is (\d+) seconds/ step definition is deprecated. Please use /^the default aruba exit timeout is (\d+) seconds/ step definition is deprecated.})
-  # rubocop:enable Metrics/LineLength
-
-  aruba.config.exit_timeout = seconds.to_i
-end
-
-Given(/^the (?:default )?aruba io wait timeout is (\d+) seconds?$/) do |seconds|
-  aruba.config.io_wait_timeout = seconds.to_i
+Given(/^the (?:default )?aruba io wait timeout is ([\d.]+) seconds?$/) do |seconds|
+  aruba.config.io_wait_timeout = seconds.to_f
 end
 
-Given(/^the (?:default )?aruba exit timeout is (\d+) seconds?$/) do |seconds|
-  aruba.config.exit_timeout = seconds.to_i
+Given(/^the (?:default )?aruba exit timeout is ([\d.]+) seconds?$/) do |seconds|
+  aruba.config.exit_timeout = seconds.to_f
 end
 
 Given(/^the (?:default )?aruba stop signal is "([^"]*)"$/) do |signal|
   aruba.config.stop_signal = signal
 end
 
-Given(/^I wait (\d+) seconds? for (?:a|the) command to start up$/) do |seconds|
-  aruba.config.startup_wait_time = seconds.to_i
+Given(/^I wait ([\d.]+) seconds? for (?:a|the) command to start up$/) do |seconds|
+  aruba.config.startup_wait_time = seconds.to_f
 end
 
 When(/^I send the signal "([^"]*)" to the command (?:"([^"]*)"|(?:started last))$/) do |signal, command|

data/lib/aruba/cucumber/environment.rb

@@ -1,4 +1,4 @@
-Given(/^a mocked home directory$/)do
+Given(/^a mocked home directory$/) do
   set_environment_variable 'HOME', expand_path('.')
 end
 

data/lib/aruba/cucumber/file.rb

@@ -3,11 +3,11 @@ Given(/^I use (?:a|the) fixture(?: named)? "([^"]*)"$/) do |name|
   cd name
 end
 
-Given(/^I copy (?:a|the) (file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |file_or_directory, source, destination|
+Given(/^I copy (?:a|the) (?:file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |source, destination|
   copy source, destination
 end
 
-Given(/^I move (?:a|the) (file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |file_or_directory, source, destination|
+Given(/^I move (?:a|the) (?:file|directory)(?: (?:named|from))? "([^"]*)" to "([^"]*)"$/) do |source, destination|
   move source, destination
 end
 
@@ -42,11 +42,11 @@ Given(/^(?:a|the) (\d+) byte file(?: named)? "([^"]*)"$/) do |file_size, file_na
 end
 
 Given(/^(?:an|the) empty file(?: named)? "([^"]*)"$/) do |file_name|
-  write_file(file_name, "")
+  write_file(file_name, '')
 end
 
 Given(/^(?:an|the) empty file(?: named)? "([^"]*)" with mode "([^"]*)"$/) do |file_name, file_mode|
-  write_file(file_name, "")
+  write_file(file_name, '')
   chmod(file_mode, file_name)
 end
 
@@ -67,11 +67,11 @@ When(/^I append to "([^"]*)" with "([^"]*)"$/) do |file_name, file_content|
 end
 
 When(/^I remove (?:a|the) (?:file|directory)(?: named)? "([^"]*)"( with full force)?$/) do |name, force_remove|
-  remove(name, :force => force_remove.nil? ? false : true)
+  remove(name, force: force_remove.nil? ? false : true)
 end
 
 Given(/^(?:a|the) (?:file|directory)(?: named)? "([^"]*)" does not exist$/) do |name|
-  remove(name, :force => true)
+  remove(name, force: true)
 end
 
 When(/^I cd to "([^"]*)"$/) do |dir|
@@ -156,7 +156,7 @@ Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?contain exactly:$/) do
   end
 end
 
-Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?match %r<([^\/]*)>$/) do |file, negated, content|
+Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?match %r<([^>]*)>$/) do |file, negated, content|
   if negated
     expect(file).not_to have_file_content file_content_matching(content)
   else
@@ -174,21 +174,9 @@ end
 
 Then(/^(?:a|the) file(?: named)? "([^"]*)" should (not )?be equal to file "([^"]*)"/) do |file, negated, reference_file|
   if negated
-    expect(file).not_to have_same_file_content_like(reference_file)
+    expect(file).not_to have_same_file_content_as(reference_file)
   else
-    expect(file).to have_same_file_content_like(reference_file)
-  end
-end
-
-Then(/^the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)"$/) do |file, negated, permissions|
-  # rubocop:disable Metrics/LineLength
-  Aruba.platform.deprecated('The use of step "the mode of filesystem object "([^"]*)" should (not )?match "([^"]*)" is deprecated. Use "^the (?:file|directory)(?: named)? "([^"]*)" should have permissions "([^"]*)"$" instead')
-  # rubocop:enable Metrics/LineLength
-
-  if negated
-    expect(file).not_to have_permissions(permissions)
-  else
-    expect(file).to have_permissions(permissions)
+    expect(file).to have_same_file_content_as(reference_file)
   end
 end