aruba 1.0.0 → 1.0.1

data/lib/aruba/api/text.rb

@@ -14,7 +14,14 @@ module Aruba
       # @param [#to_s] text
       #   Input
       def unescape_text(text)
-        text.gsub('\n', "\n").gsub('\"', '"').gsub('\e', "\e").gsub('\033', "\e").gsub('\016', "\016").gsub('\017', "\017").gsub('\t', "\t")
+        text
+          .gsub('\n', "\n")
+          .gsub('\"', '"')
+          .gsub('\e', "\e")
+          .gsub('\033', "\e")
+          .gsub('\016', "\016")
+          .gsub('\017', "\017")
+          .gsub('\t', "\t")
       end
 
       # Remove ansi characters from text
@@ -22,7 +29,10 @@ module Aruba
       # @param [#to_s] text
       #   Input
       def extract_text(text)
-        text.gsub(/(?:\e|\033)\[\d+(?>(;\d+)*)m/, '').gsub(/\\\[|\\\]/, '').gsub(/\007|\016|\017/, '')
+        text
+          .gsub(/(?:\e|\033)\[\d+(?>(;\d+)*)m/, '')
+          .gsub(/\\\[|\\\]/, '')
+          .gsub(/\007|\016|\017/, '')
       end
 
       # Unescape special characters and remove ANSI characters
@@ -41,7 +51,9 @@ module Aruba
       # @param [#to_s] text
       #   The text to parse
       def replace_variables(text)
-        text = text.gsub(/<pid-last-command-started>/, last_command_started.pid.to_s) if text.include? '<pid-last-command-started>'
+        if text.include? '<pid-last-command-started>'
+          text = text.gsub(/<pid-last-command-started>/, last_command_started.pid.to_s)
+        end
 
         text
       end

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)
@@ -210,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/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

@@ -20,7 +20,8 @@ module Aruba
     option_reader :root_directory, contract: { None => String }, default: Dir.getwd
 
     option_accessor :working_directory,
-                    contract: { Aruba::Contracts::RelativePath => Aruba::Contracts::RelativePath },
+                    contract: { Aruba::Contracts::RelativePath =>
+                                Aruba::Contracts::RelativePath },
                     default: 'tmp/aruba'
 
     option_reader :fixtures_path_prefix, contract: { None => String }, default: '%'
@@ -36,34 +37,48 @@ module Aruba
     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')]
+                      [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] },
+                    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
+                    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] },
+                    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 },
+                    contract: { Aruba::Contracts::IsPowerOfTwo =>
+                                Aruba::Contracts::IsPowerOfTwo },
                     default: 512
-    option_accessor :console_history_file, contract: { String => String }, default: '~/.aruba_history'
+    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 :activate_announcer_on_command_failure,
+                    contract: { ArrayOf[Symbol] => ArrayOf[Symbol] },
+                    default: []
     option_accessor :allow_absolute_paths, contract: { Bool => 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

@@ -10,7 +10,8 @@ module Aruba
       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 'Documentation:'
+        puts '* http://www.rubydoc.info/gems/aruba'
         puts
 
         nil
@@ -18,7 +19,9 @@ 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/contracts/absolute_path.rb

@@ -12,7 +12,7 @@ module Aruba
       #   The value to be checked
       def self.valid?(value)
         Aruba.platform.absolute_path? value
-      rescue
+      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

@@ -12,7 +12,7 @@ module Aruba
       #   The path to be checked
       def self.valid?(value)
         Aruba.platform.relative_path? value
-      rescue
+      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
@@ -119,7 +121,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 +139,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 +156,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 +195,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 +209,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 +229,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 +252,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 +389,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 +435,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