aruba 1.0.0.pre.alpha.5 → 1.0.4

data/lib/aruba/configuration.rb

@@ -17,52 +17,59 @@ module Aruba
   #
   # This defines the configuration options of aruba
   class Configuration < BasicConfiguration
-    option_reader :root_directory, contract: { None => String }, default: Dir.getwd
+    option_reader :root_directory, type: String, default: Dir.getwd
 
     option_accessor :working_directory,
-                    contract: { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath },
+                    type: Aruba::Contracts::RelativePath,
                     default: 'tmp/aruba'
 
-    option_reader :fixtures_path_prefix, contract: { None => String }, default: '%'
+    option_reader :fixtures_path_prefix, type: 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 :exit_timeout, type: Num, default: 15
+    option_accessor :stop_signal, type: Maybe[String], default: nil
+    option_accessor :io_wait_timeout, type: Num, default: 0.1
+    option_accessor :startup_wait_time, type: Num, default: 0
     option_accessor :fixtures_directories,
-                    contract: { Array => ArrayOf[String] },
+                    type: ArrayOf[String],
                     default: %w(features/fixtures spec/fixtures test/fixtures fixtures)
 
-    option_accessor :command_runtime_environment, contract: { Hash => Hash }, default: {}
+    option_accessor :command_runtime_environment, type: 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')]
+                    type: 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 :remove_ansi_escape_sequences, type: Bool, default: true
     option_accessor :command_launcher,
-                    contract: { Aruba::Contracts::Enum[:in_process, :spawn, :debug] => Aruba::Contracts::Enum[:in_process, :spawn, :debug] },
+                    type: Aruba::Contracts::Enum[:in_process, :spawn, :debug],
                     default: :spawn
-    option_accessor :main_class, contract: { Class => Maybe[Class] }, default: nil
+    option_accessor :main_class, type: 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
+                    type: 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] },
+                    type:
+                        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 },
+                    type: Aruba::Contracts::IsPowerOfTwo,
                     default: 512
-    option_accessor :console_history_file, contract: { String => String }, default: '~/.aruba_history'
+    option_accessor :console_history_file, type: 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
+    option_accessor :activate_announcer_on_command_failure,
+                    type: ArrayOf[Symbol],
+                    default: []
+    option_accessor :allow_absolute_paths, type: Bool, default: false
   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
@@ -63,6 +62,5 @@ module Aruba
         IRB.irb_at_exit
       end
     end
-    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/aruba/console/help.rb

@@ -8,9 +8,10 @@ module Aruba
     module Help
       # Output help information
       def aruba_help
-        puts 'Aruba Version: ' + Aruba::VERSION
-        puts 'Issue Tracker: ' + 'https://github.com/cucumber/aruba/issues'
-        puts "Documentation:\n" + %w(http://www.rubydoc.info/gems/aruba).map { |d| format('* %s', d) }.join("\n")
+        puts "Aruba Version: #{Aruba::VERSION}"
+        puts 'Issue Tracker: https://github.com/cucumber/aruba/issues'
+        puts 'Documentation:'
+        puts '* http://www.rubydoc.info/gems/aruba'
         puts
 
         nil
@@ -18,9 +19,11 @@ 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")
+        puts "Available Methods:\n#{ms.join("\n")}"
 
         nil
       end

data/lib/aruba/contracts/absolute_path.rb

@@ -1,4 +1,4 @@
-require 'aruba/aruba_path'
+require 'aruba/platform'
 
 # Aruba
 module Aruba
@@ -11,8 +11,8 @@ module Aruba
       # @param [Object] value
       #   The value to be checked
       def self.valid?(value)
-        ArubaPath.new(value).absolute?
-      rescue
+        Aruba.platform.absolute_path? value
+      rescue StandardError
         false
       end
     end

data/lib/aruba/contracts/is_power_of_two.rb

@@ -13,8 +13,8 @@ module Aruba
       def self.valid?(value)
         # explanation for algorithm can be found here:
         # http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/
-        value != 0 && (value & (value - 1)) == 0 ? true : false
-      rescue
+        value.positive? && (value & (value - 1)).zero?
+      rescue StandardError
         false
       end
     end

data/lib/aruba/contracts/relative_path.rb

@@ -1,4 +1,4 @@
-require 'aruba/aruba_path'
+require 'aruba/platform'
 
 # Aruba
 module Aruba
@@ -11,8 +11,8 @@ module Aruba
       # @param [String] value
       #   The path to be checked
       def self.valid?(value)
-        ArubaPath.new(value).relative?
-      rescue
+        Aruba.platform.relative_path? value
+      rescue StandardError
         false
       end
     end

data/lib/aruba/cucumber/command.rb

@@ -12,7 +12,8 @@ When(/^I successfully run `(.*?)`(?: for up to ([\d.]+) seconds)?$/) do |cmd, se
   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|
+When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) \
+  do |shell, commands|
   full_path = expand_path('bin/myscript')
 
   Aruba.platform.mkdir(expand_path('bin'))
@@ -61,7 +62,8 @@ When(/^I (terminate|stop) the command (?:"([^"]*)"|(?:started last))$/) do |sign
   end
 end
 
-When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$/) do |channel, expected|
+When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$/) \
+  do |channel, expected|
   begin
     Timeout.timeout(aruba.config.exit_timeout) do
       loop do
@@ -86,30 +88,22 @@ end
 
 When(/^I wait for (?:output|stdout) to contain:$/) do |expected|
   Timeout.timeout(aruba.config.exit_timeout) do
-    loop do
-      begin
-        expect(last_command_started).to have_output an_output_string_including(expected)
-      rescue ExpectationError
-        sleep 0.1
-        retry
-      end
-
-      break
+    begin
+      expect(last_command_started).to have_output an_output_string_including(expected)
+    rescue ExpectationError
+      sleep 0.1
+      retry
     end
   end
 end
 
 When(/^I wait for (?:output|stdout) to contain "([^"]*)"$/) do |expected|
   Timeout.timeout(aruba.config.exit_timeout) do
-    loop do
-      begin
-        expect(last_command_started).to have_output an_output_string_including(expected)
-      rescue ExpectationError
-        sleep 0.1
-        retry
-      end
-
-      break
+    begin
+      expect(last_command_started).to have_output an_output_string_including(expected)
+    rescue ExpectationError
+      sleep 0.1
+      retry
     end
   end
 end
@@ -119,7 +113,8 @@ Then(/^the output should be (\d+) bytes long$/) do |size|
 end
 
 ## the stderr should contain "hello"
-Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)"$/) do |channel, negated, exactly, expected|
+Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)"$/) \
+  do |channel, negated, exactly, expected|
   combined_output = send("all_#{channel}")
 
   output_string_matcher = if exactly
@@ -136,14 +131,13 @@ Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)
 end
 
 ## the stderr from "echo -n 'Hello'" should contain "hello"
-Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exactly)? "([^"]*)"$/) do |channel, cmd, negated, exactly, expected|
-  matcher = case channel.to_sym
-            when :output
-              :have_output
-            when :stderr
-              :have_output_on_stderr
-            when :stdout
-              :have_output_on_stdout
+Then(
+  /^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)? "([^"]*)"$/
+) do |channel, cmd, exactly, expected|
+  matcher = case channel
+            when 'output'; then :have_output
+            when 'stderr'; then :have_output_on_stderr
+            when 'stdout'; then :have_output_on_stdout
             end
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
@@ -154,15 +148,33 @@ Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should( not)? contain( exa
                             :an_output_string_including
                           end
 
-  if negated
-    expect(command).not_to send(matcher, send(output_string_matcher, expected))
-  else
-    expect(command).to send(matcher, send(output_string_matcher, expected))
-  end
+  expect(command).to send(matcher, send(output_string_matcher, expected))
+end
+
+## the stderr from "echo -n 'Hello'" should not contain "hello"
+Then(
+  /^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactly)? "([^"]*)"$/
+) do |channel, cmd, exactly, expected|
+  matcher = case channel
+            when 'output'; then :have_output
+            when 'stderr'; then :have_output_on_stderr
+            when 'stdout'; then :have_output_on_stdout
+            end
+
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  expect(command).not_to send(matcher, send(output_string_matcher, expected))
 end
 
 ## the stderr should not contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) should not contain( exactly)?:$/) do |channel, exactly, expected|
+Then(/^(?:the )?(output|stderr|stdout) should not contain( exactly)?:$/) \
+  do |channel, exactly, expected|
   combined_output = send("all_#{channel}")
 
   output_string_matcher = if exactly
@@ -175,7 +187,8 @@ Then(/^(?:the )?(output|stderr|stdout) should not contain( exactly)?:$/) do |cha
 end
 
 ## the stderr should contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) do |channel, exactly, expected|
+Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) \
+  do |channel, exactly, expected|
   combined_output = send("all_#{channel}")
 
   output_string_matcher = if exactly
@@ -188,14 +201,12 @@ Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) do |channel
 end
 
 ## the stderr from "echo -n 'Hello'" should not contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactly)?:$/) do |channel, cmd, exactly, expected|
-  matcher = case channel.to_sym
-            when :output
-              :have_output
-            when :stderr
-              :have_output_on_stderr
-            when :stdout
-              :have_output_on_stdout
+Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactly)?:$/) \
+  do |channel, cmd, exactly, expected|
+  matcher = case channel
+            when 'output'; then :have_output
+            when 'stderr'; then :have_output_on_stderr
+            when 'stdout'; then :have_output_on_stdout
             end
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
@@ -210,14 +221,12 @@ Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should not contain( exactl
 end
 
 ## the stderr from "echo -n 'Hello'" should contain exactly:
-Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)?:$/) do |channel, cmd, exactly, expected|
-  matcher = case channel.to_sym
-            when :output
-              :have_output
-            when :stderr
-              :have_output_on_stderr
-            when :stdout
-              :have_output_on_stdout
+Then(/^(?:the )?(output|stderr|stdout) from "([^"]*)" should contain( exactly)?:$/) \
+  do |channel, cmd, exactly, expected|
+  matcher = case channel
+            when 'output'; then :have_output
+            when 'stderr'; then :have_output_on_stderr
+            when 'stdout'; then :have_output_on_stdout
             end
 
   command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
@@ -235,34 +244,38 @@ end
 # you don't need regex, use "the output should contain" instead since
 # that way, you don't have to escape regex characters that
 # appear naturally in the output
-Then(/^the output should( not)? match \/([^\/]*)\/$/) do |negated, expected|
+Then(%r{^the output should( not)? match /([^/]*)/$}) do |negated, expected|
   if negated
-    expect(all_commands).not_to include_an_object have_output an_output_string_matching(expected)
+    expect(all_commands)
+      .not_to include_an_object have_output an_output_string_matching(expected)
   else
-    expect(all_commands).to include_an_object have_output an_output_string_matching(expected)
+    expect(all_commands)
+      .to include_an_object have_output an_output_string_matching(expected)
   end
 end
 
 Then(/^the output should( not)? match %r<([^>]*)>$/) do |negated, expected|
   if negated
-    expect(all_commands).not_to include_an_object have_output an_output_string_matching(expected)
+    expect(all_commands)
+      .not_to include_an_object have_output an_output_string_matching(expected)
   else
-    expect(all_commands).to include_an_object have_output an_output_string_matching(expected)
+    expect(all_commands)
+      .to include_an_object have_output an_output_string_matching(expected)
   end
 end
 
 Then(/^the output should( not)? match:$/) do |negated, expected|
   if negated
-    expect(all_commands).not_to include_an_object have_output an_output_string_matching(expected)
+    expect(all_commands)
+      .not_to include_an_object have_output an_output_string_matching(expected)
   else
-    expect(all_commands).to include_an_object have_output an_output_string_matching(expected)
+    expect(all_commands)
+      .to include_an_object have_output an_output_string_matching(expected)
   end
 end
 
 Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
-  if last_command_stopped.nil?
-    last_command_started.stop
-  end
+  last_command_started.stop if last_command_stopped.nil?
 
   if negated
     expect(last_command_stopped).not_to have_exit_status exit_status.to_i
@@ -368,35 +381,32 @@ Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expect
 end
 
 Then(/^(?:the )?(output|stderr|stdout) should not contain anything$/) do |channel|
-  matcher = case channel.to_sym
-            when :output
-              :have_output
-            when :stderr
-              :have_output_on_stderr
-            when :stdout
-              :have_output_on_stdout
+  matcher = case channel
+            when 'output'; then :have_output
+            when 'stderr'; then :have_output_on_stderr
+            when 'stdout'; then :have_output_on_stdout
             end
 
   expect(all_commands).to include_an_object send(matcher, be_nil.or(be_empty))
 end
 
-Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) do |channel, negated, table|
+Then(/^(?:the )?(output|stdout|stderr) should( not)? contain all of these lines:$/) \
+  do |channel, negated, table|
   table.raw.flatten.each do |expected|
-    case channel.to_sym
-    when :output
-      :have_output
-    when :stderr
-      :have_output_on_stderr
-    when :stdout
-      :have_output_on_stdout
-    end
+    _matcher = case channel
+               when 'output'; then :have_output
+               when 'stderr'; then :have_output_on_stderr
+               when 'stdout'; then :have_output_on_stdout
+               end
 
     # TODO: This isn't actually using the above. It's hardcoded to use have_output only
 
     if negated
-      expect(all_commands).not_to include_an_object have_output an_output_string_including(expected)
+      expect(all_commands)
+        .not_to include_an_object have_output an_output_string_including(expected)
     else
-      expect(all_commands).to include_an_object have_output an_output_string_including(expected)
+      expect(all_commands)
+        .to include_an_object have_output an_output_string_including(expected)
     end
   end
 end
@@ -417,10 +427,11 @@ Given(/^I wait ([\d.]+) seconds? for (?:a|the) command to start up$/) do |second
   aruba.config.startup_wait_time = seconds.to_f
 end
 
-When(/^I send the signal "([^"]*)" to the command (?:"([^"]*)"|(?:started last))$/) do |signal, command|
+When(/^I send the signal "([^"]*)" to 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?
+    raise ArgumentError, %(No command "#{command}" found) if cmd.nil?
 
     cmd.send_signal signal
   else