aruba 1.0.0 → 1.1.0

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

@@ -1,6 +1,6 @@
-require 'thor'
-require 'aruba/console'
-require 'aruba/initializer'
+require "thor"
+require "aruba/console"
+require "aruba/initializer"
 
 # Aruba
 module Aruba
@@ -12,13 +12,16 @@ module Aruba
       true
     end
 
-    desc 'console', "Start aruba's console"
+    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'
+    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

data/lib/aruba/command.rb

@@ -1,7 +1,7 @@
-require 'delegate'
-require 'aruba/processes/spawn_process'
-require 'aruba/processes/in_process'
-require 'aruba/processes/debug_process'
+require "delegate"
+require "aruba/processes/spawn_process"
+require "aruba/processes/in_process"
+require "aruba/processes/debug_process"
 
 # Aruba
 module Aruba

data/lib/aruba/config/jruby.rb

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

@@ -1,15 +1,15 @@
-require 'contracts'
+require "contracts"
 
-require 'aruba/version'
-require 'aruba/basic_configuration'
-require 'aruba/in_config_wrapper'
-require 'aruba/hooks'
+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/relative_path"
+require "aruba/contracts/absolute_path"
+require "aruba/contracts/enum"
 
-require 'aruba/contracts/is_power_of_two'
+require "aruba/contracts/is_power_of_two"
 
 # Aruba
 module Aruba
@@ -17,54 +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 },
-                    default: 'tmp/aruba'
+                    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|
+                    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

@@ -1,7 +1,7 @@
-require 'irb'
+require "irb"
 
-require 'aruba/api'
-require 'aruba/console/help'
+require "aruba/api"
+require "aruba/console/help"
 
 # Aruba
 module Aruba
@@ -9,28 +9,27 @@ 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
       ARGV.clear
       IRB.setup nil
 
-      IRB.conf[:IRB_NAME] = 'aruba'
+      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* ',
+        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'
+      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
@@ -44,14 +43,14 @@ module Aruba
         end
 
         def inspect
-          'nil'
+          "nil"
         end
       end
 
       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

data/lib/aruba/console/help.rb

@@ -1,4 +1,4 @@
-require 'aruba/api'
+require "aruba/api"
 
 # Aruba
 module Aruba
@@ -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/platform'
+require "aruba/platform"
 
 # Aruba
 module Aruba
@@ -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/enum.rb

@@ -1,4 +1,4 @@
-require 'contracts'
+require "contracts"
 
 # Aruba
 module Aruba

data/lib/aruba/contracts/is_power_of_two.rb

@@ -1,4 +1,4 @@
-require 'aruba/aruba_path'
+require "aruba/aruba_path"
 
 # Aruba
 module Aruba
@@ -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/platform'
+require "aruba/platform"
 
 # Aruba
 module Aruba
@@ -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.rb

@@ -1,8 +1,8 @@
-require 'aruba/version'
+require "aruba/version"
 
-require 'aruba/api'
-require 'aruba/cucumber/hooks'
-require 'aruba/cucumber/command'
-require 'aruba/cucumber/environment'
-require 'aruba/cucumber/file'
-require 'aruba/cucumber/testing_frameworks'
+require "aruba/api"
+require "aruba/cucumber/hooks"
+require "aruba/cucumber/command"
+require "aruba/cucumber/environment"
+require "aruba/cucumber/file"
+require "aruba/cucumber/testing_frameworks"

data/lib/aruba/cucumber/command.rb

@@ -1,4 +1,4 @@
-require 'aruba/generators/script_file'
+require "aruba/generators/script_file"
 
 When(/^I run `([^`]*)`$/) do |cmd|
   cmd = sanitize_text(cmd)
@@ -12,10 +12,11 @@ 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|
-  full_path = expand_path('bin/myscript')
+When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) \
+  do |shell, commands|
+  full_path = expand_path("bin/myscript")
 
-  Aruba.platform.mkdir(expand_path('bin'))
+  Aruba.platform.mkdir(expand_path("bin"))
   shell ||= Aruba.platform.default_shell
 
   Aruba::ScriptFile.new(interpreter: shell, content: commands, path: full_path).call
@@ -54,14 +55,15 @@ When(/^I (terminate|stop) the command (?:"([^"]*)"|(?:started last))$/) do |sign
           last_command_started
         end
 
-  if signal == 'terminate'
+  if signal == "terminate"
     cmd.terminate
   else
     cmd.stop
   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
@@ -274,7 +287,7 @@ end
 Then(/^it should not (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -286,7 +299,7 @@ end
 Then(/^it should (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -298,7 +311,7 @@ end
 Then(/^it should not (pass|fail) with:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -310,7 +323,7 @@ end
 Then(/^it should (pass|fail) with:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -322,7 +335,7 @@ end
 Then(/^it should not (pass|fail) with exactly:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -334,7 +347,7 @@ end
 Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -346,7 +359,7 @@ end
 Then(/^it should not (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -358,7 +371,7 @@ end
 Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
   last_command_started.stop
 
-  if pass_fail == 'pass'
+  if pass_fail == "pass"
     expect(last_command_stopped).to be_successfully_executed
   else
     expect(last_command_stopped).not_to be_successfully_executed
@@ -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
@@ -429,5 +440,5 @@ When(/^I send the signal "([^"]*)" to the command (?:"([^"]*)"|(?:started last))
 end
 
 Given(/^I look for executables in "(.*)" within the current directory$/) do |directory|
-  prepend_environment_variable 'PATH', expand_path(directory) + File::PATH_SEPARATOR
+  prepend_environment_variable "PATH", expand_path(directory) + File::PATH_SEPARATOR
 end