aruba 1.0.0.pre.alpha.3 → 1.0.2

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/colorizer.rb

@@ -1,108 +1,19 @@
+# Aruba
 module Aruba
-  # The ANSIColor module can be used for namespacing and mixed into your own
-  # classes.
-  module AnsiColor
-    # :stopdoc:
-    ATTRIBUTES = [
-      [:clear,   0],
-      [:reset,   0], # synonym for :clear
-      [:bold,   1],
-      [:dark,   2],
-      [:italic, 3], # not widely implemented
-      [:underline, 4],
-      [:underscore, 4], # synonym for :underline
-      [:blink, 5],
-      [:rapid_blink, 6], # not widely implemented
-      [:negative, 7], # no reverse because of String#reverse
-      [:concealed, 8],
-      [:strikethrough, 9], # not widely implemented
-      [:black, 30],
-      [:red, 31],
-      [:green, 32],
-      [:yellow, 33],
-      [:blue, 34],
-      [:magenta, 35],
-      [:cyan, 36],
-      [:white, 37],
-      [:on_black, 40],
-      [:on_red, 41],
-      [:on_green, 42],
-      [:on_yellow, 43],
-      [:on_blue, 44],
-      [:on_magenta, 45],
-      [:on_cyan, 46],
-      [:on_white, 47]
-    ].freeze
-
-    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
-    # :startdoc:
-
-    # Returns true, if the coloring function of this module
-    # is switched on, false otherwise.
-    def self.coloring?
-      @coloring
-    end
-
-    # Turns the coloring on or off globally, so you can easily do
-    # this for example:
-    #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
-    def self.coloring=(val)
-      @coloring = val
-    end
-    self.coloring = true
-
-    ATTRIBUTES.each do |c, v|
-      define_method(c) do |string|
-        result = ''
-        result << "\e[#{v}m" if Aruba::AnsiColor.coloring?
-        if block_given?
-          result << yield
-        elsif string
-          result << string
-        elsif respond_to?(:to_str)
-          result << to_str
-        else
-          return result # only switch on
-        end
-        result << "\e[0m" if Aruba::AnsiColor.coloring?
-        result
-      end
-    end
-
-    # Regular expression that is used to scan for ANSI-sequences while
-    # uncoloring strings.
-    COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
-
-    def self.included(klass)
-      return unless klass == String
+  # Simple colorizer class. Only supports the color cyan
+  class Colorizer
+    class << self
+      attr_accessor :coloring
 
-      ATTRIBUTES.delete(:clear)
-      ATTRIBUTE_NAMES.delete(:clear)
+      alias coloring? coloring
     end
 
-    # Returns an uncolored version of the string, that is all
-    # ANSI-sequences are stripped from the string.
-    def uncolored(string = nil) # :yields:
-      if block_given?
-        yield.gsub(COLORED_REGEXP, '')
-      elsif string
-        string.gsub(COLORED_REGEXP, '')
-      elsif respond_to?(:to_str)
-        to_str.gsub(COLORED_REGEXP, '')
+    def cyan(string)
+      if self.class.coloring?
+        "\e[36m#{string}\e[0m"
       else
-        ''
+        string
       end
     end
-
-    # Returns an array of all Aruba::Platforms::AnsiColor attributes as symbols.
-    def attributes
-      ATTRIBUTE_NAMES
-    end
-  end
-end
-
-module Aruba
-  class Colorizer
-    include Aruba::AnsiColor
   end
 end

data/lib/aruba/config/jruby.rb

@@ -2,16 +2,26 @@ require 'rbconfig'
 
 # ideas taken from: http://blog.headius.com/2010/03/jruby-startup-time-tips.html
 Aruba.configure do |config|
-  config.before :command do
+  config.before :command do |command|
     next unless RUBY_PLATFORM == 'java'
 
+    env = command.environment
+
+    jruby_opts = env['JRUBY_OPTS'] || ''
+
     # disable JIT since these processes are so short lived
-    ENV['JRUBY_OPTS'] = "-X-C #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '') .include? '-X-C'
+    jruby_opts = "-X-C #{jruby_opts}" unless jruby_opts.include? '-X-C'
 
     # Faster startup for jruby
-    ENV['JRUBY_OPTS'] = "--dev #{ENV['JRUBY_OPTS']}" unless (ENV['JRUBY_OPTS'] || '').include? '--dev'
+    jruby_opts = "--dev #{jruby_opts}" unless jruby_opts.include? '--dev'
+
+    env['JRUBY_OPTS'] = jruby_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 #{ENV['JAVA_OPTS']}" if RbConfig::CONFIG['host_os'] =~ /solaris|sunos/i && !(ENV['JAVA_OPTS'] || '').include?('-d32')
+      # force jRuby to use client JVM for faster startup times
+      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

@@ -19,7 +19,10 @@ module 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_accessor :working_directory,
+                    contract: { Aruba::Contracts::RelativePath =>
+                                Aruba::Contracts::RelativePath },
+                    default: 'tmp/aruba'
 
     option_reader :fixtures_path_prefix, contract: { None => String }, default: '%'
 
@@ -27,29 +30,55 @@ module Aruba
     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 :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 :command_search_paths,
+                    contract: { ArrayOf[String] => 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
-    # 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 :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 :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
+    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 :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 :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

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

@@ -1,8 +1,6 @@
 require 'aruba/version'
 
 require 'aruba/api'
-World(Aruba::Api)
-
 require 'aruba/cucumber/hooks'
 require 'aruba/cucumber/command'
 require 'aruba/cucumber/environment'

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'))
@@ -23,8 +24,7 @@ When(/^I run the following (?:commands|script)(?: (?:with|in) `([^`]+)`)?:$/) do
 end
 
 When(/^I run `([^`]*)` interactively$/) do |cmd|
-  cmd = sanitize_text(cmd)
-  @interactive = run_command(cmd)
+  run_command(sanitize_text(cmd))
 end
 
 # Merge interactive and background after refactoring with event queue
@@ -62,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
@@ -80,7 +81,7 @@ When(/^I stop the command(?: started last)? if (output|stdout|stderr) contains:$
         sleep 0.1
       end
     end
-  rescue ChildProcess::TimeoutError, TimeoutError
+  rescue ChildProcess::TimeoutError, Timeout::Error
     last_command_started.terminate
   end
 end
@@ -119,21 +120,10 @@ Then(/^the output should be (\d+) bytes long$/) do |size|
   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|
-  matcher = case channel.to_sym
-            when :output
-              :have_output
-            when :stderr
-              :have_output_on_stderr
-            when :stdout
-              :have_output_on_stdout
-            end
-
-  commands = if cmd
-               [aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))]
-             else
-               all_commands
-             end
+## the stderr should contain "hello"
+Then(/^(?:the )?(output|stderr|stdout) should( not)? contain( exactly)? "([^"]*)"$/) \
+  do |channel, negated, exactly, expected|
+  combined_output = send("all_#{channel}")
 
   output_string_matcher = if exactly
                             :an_output_string_being_eq
@@ -142,33 +132,112 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
                           end
 
   if negated
-    expect(commands).not_to include_an_object send(matcher, send(output_string_matcher, expected))
+    expect(combined_output).not_to send(output_string_matcher, expected)
   else
-    expect(commands).to include_an_object send(matcher, send(output_string_matcher, expected))
+    expect(combined_output).to send(output_string_matcher, expected)
   end
 end
 
-## the stderr should contain "hello"
 ## the stderr from "echo -n 'Hello'" should contain "hello"
+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))
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          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|
+  combined_output = send("all_#{channel}")
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  expect(combined_output).not_to send(output_string_matcher, expected)
+end
+
 ## the stderr should contain exactly:
+Then(/^(?:the )?(output|stderr|stdout) should contain( exactly)?:$/) \
+  do |channel, exactly, expected|
+  combined_output = send("all_#{channel}")
+
+  output_string_matcher = if exactly
+                            :an_output_string_being_eq
+                          else
+                            :an_output_string_including
+                          end
+
+  expect(combined_output).to send(output_string_matcher, expected)
+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
+            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 from "echo -n 'Hello'" should contain exactly:
-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
-            else
-              fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stderr" or "stdout" are allowed.)
+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
 
-  commands = if cmd
-               [aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))]
-             else
-               all_commands
-             end
+  command = aruba.command_monitor.find(Aruba.platform.detect_ruby(cmd))
 
   output_string_matcher = if exactly
                             :an_output_string_being_eq
@@ -176,45 +245,45 @@ Then(/^(?:the )?(output|stderr|stdout)(?: from "([^"]*)")? should( not)? contain
                             :an_output_string_including
                           end
 
-  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(command).to send(matcher, send(output_string_matcher, expected))
 end
 
 # "the output should match" allows regex in the partial_output, if
 # 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
@@ -223,7 +292,7 @@ Then(/^the exit status should( not)? be (\d+)$/) do |negated, exit_status|
   end
 end
 
-Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -232,14 +301,22 @@ Then(/^it should( not)? (pass|fail) with "(.*?)"$/) do |negated, pass_fail, expe
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+end
+
+Then(/^it should (pass|fail) with "(.*?)"$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_including(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_including(expected)
 end
 
-Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with:$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -248,14 +325,22 @@ Then(/^it should( not)? (pass|fail) with:$/) do |negated, pass_fail, expected|
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_including(expected)
+end
+
+Then(/^it should (pass|fail) with:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_including(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_including(expected)
 end
 
-Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) with exactly:$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -264,14 +349,22 @@ Then(/^it should( not)? (pass|fail) with exactly:$/) do |negated, pass_fail, exp
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_eq(expected)
+end
+
+Then(/^it should (pass|fail) with exactly:$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_being_eq(expected)
 end
 
-Then(/^it should( not)? (pass|fail) (?:with regexp?|matching):$/) do |negated, pass_fail, expected|
+Then(/^it should not (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
   last_command_started.stop
 
   if pass_fail == 'pass'
@@ -280,45 +373,48 @@ Then(/^it should( not)? (pass|fail) (?:with regexp?|matching):$/) do |negated, p
     expect(last_command_stopped).not_to be_successfully_executed
   end
 
-  if negated
-    expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+  expect(last_command_stopped).not_to have_output an_output_string_matching(expected)
+end
+
+Then(/^it should (pass|fail) (?:with regexp?|matching):$/) do |pass_fail, expected|
+  last_command_started.stop
+
+  if pass_fail == 'pass'
+    expect(last_command_stopped).to be_successfully_executed
   else
-    expect(last_command_stopped).to have_output an_output_string_matching(expected)
+    expect(last_command_stopped).not_to be_successfully_executed
   end
+
+  expect(last_command_stopped).to have_output an_output_string_matching(expected)
 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
-            else
-              fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
+  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
-    else
-      fail ArgumentError, %(Invalid channel "#{channel}" chosen. Only "output", "stdout" and "stderr" are supported.)
-    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
@@ -339,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