aruba 0.9.0.pre → 0.9.0.pre2

data/lib/aruba/cucumber/hooks.rb

@@ -1,21 +1,11 @@
 require 'aruba/aruba_path'
 require 'aruba/api'
+require 'aruba/platform'
 World(Aruba::Api)
 
 if Aruba::VERSION >= '1.0.0'
   Around do |_, block|
-    begin
-      if RUBY_VERSION < '1.9'
-        old_env = ENV.to_hash.dup
-      else
-        old_env = ENV.to_h.dup
-      end
-
-      block.call
-    ensure
-      ENV.clear
-      ENV.update old_env
-    end
+    Aruba.platform.with_environment(&block)
   end
 end
 
@@ -30,7 +20,7 @@ end
 
 After do
   restore_env
-  process_monitor.stop_processes!
+  terminate_all_commands
   process_monitor.clear
 end
 
@@ -52,6 +42,11 @@ Before('@announce-cmd') do
   announcer.activate :command
 end
 
+Before('@announce-output') do
+  announcer.activate :stdout
+  announcer.activate :stderr
+end
+
 Before('@announce-stdout') do
   announcer.activate :stdout
 end
@@ -114,7 +109,9 @@ end
 # end
 
 Before('@ansi') do
-  Aruba.platform.deprecated('The use of "@ansi" is deprecated. Use "@keep-ansi-escape-sequences" instead')
+  # rubocop:disable Metrics/LineLength
+  Aruba::Platform.deprecated('The use of "@ansi" is deprecated. Use "@keep-ansi-escape-sequences" instead. But be aware, that this hook uses the aruba configuration and not an instance variable')
+  # rubocop:enable Metrics/LineLength
 
   aruba.config.remove_ansi_escape_sequences = false
 end

data/lib/aruba/cucumber/rvm.rb

@@ -0,0 +1,3 @@
+Given(/^I'm using a clean gemset "([^"]*)"$/) do |gemset|
+  use_clean_gemset(gemset)
+end

data/lib/aruba/matchers/base/base_matcher.rb

@@ -0,0 +1,94 @@
+require 'rspec/support/object_formatter'
+
+module Aruba
+  module Matchers
+    # Base Matcher
+    class BaseMatcher
+      # @api private
+      # Used to detect when no arg is passed to `initialize`.
+      # `nil` cannot be used because it's a valid value to pass.
+      UNDEFINED = Object.new.freeze
+
+      # @private
+      attr_reader :actual, :expected, :rescued_exception
+
+      def initialize(expected = UNDEFINED)
+        @expected = expected unless UNDEFINED.equal?(expected)
+      end
+
+      # @api private
+      # Indicates if the match is successful. Delegates to `match`, which
+      # should be defined on a subclass. Takes care of consistently
+      # initializing the `actual` attribute.
+      def matches?(actual)
+        @actual = actual
+        match(expected, actual)
+      end
+
+      def iterable?
+        @actual.respond_to?(:each_with_index)
+      end
+
+      # @private
+      module HashFormatting
+        # `{ :a => 5, :b => 2 }.inspect` produces:
+        #
+        #     {:a=>5, :b=>2}
+        #
+        # ...but it looks much better as:
+        #
+        #     {:a => 5, :b => 2}
+        #
+        # This is idempotent and safe to run on a string multiple times.
+        def improve_hash_formatting(inspect_string)
+          inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
+        end
+        module_function :improve_hash_formatting
+      end
+
+      include HashFormatting
+
+      # @api private
+      # Provides default implementations of failure messages, based on the `description`.
+      module DefaultFailureMessages
+        # @api private
+        # Provides a good generic failure message. Based on `description`.
+        # When subclassing, if you are not satisfied with this failure message
+        # you often only need to override `description`.
+        # @return [String]
+        def failure_message
+          "expected #{description_of @actual} to #{description}"
+        end
+
+        # @api private
+        # Provides a good generic negative failure message. Based on `description`.
+        # When subclassing, if you are not satisfied with this failure message
+        # you often only need to override `description`.
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{description_of @actual} not to #{description}"
+        end
+
+        # @private
+        # rubocop:disable Style/PredicateName
+        def self.has_default_failure_messages?(matcher)
+          matcher.method(:failure_message).owner == self &&
+            matcher.method(:failure_message_when_negated).owner == self
+        rescue NameError
+          false
+        end
+        # rubocop:enable Style/PredicateName
+      end
+
+      include DefaultFailureMessages
+
+      # Returns the description of the given object in a way that is
+      # aware of composed matchers. If the object is a matcher with
+      # a `description` method, returns the description; otherwise
+      # returns `object.inspect`.
+      def description_of(object)
+        RSpec::Support::ObjectFormatter.format(object)
+      end
+    end
+  end
+end

data/lib/aruba/matchers/collection.rb

@@ -0,0 +1 @@
+Aruba.platform.require_matching_files('../collection/**/*.rb', __FILE__)

data/lib/aruba/matchers/collection/all_objects.rb

@@ -0,0 +1,2 @@
+# Let's alias :all to have a name which has no conflicts with other libraries
+RSpec::Matchers.alias_matcher :all_objects, :all

data/lib/aruba/matchers/collection/include_an_object.rb

@@ -0,0 +1,120 @@
+require 'aruba/matchers/base/base_matcher'
+
+module Aruba
+  module Matchers
+    # @api private
+    # Provides the implementation for `include_an_object`.
+    # Not intended to be instantiated directly.
+    class IncludeAnObject < BaseMatcher
+      protected
+
+      # @private
+      attr_reader :matcher, :failed_objects
+      # @private
+      attr_accessor :any_succeeded_object
+
+      public
+
+      def initialize(matcher)
+        @matcher              = matcher
+        @failed_objects       = {}
+        @any_succeeded_object = false
+      end
+
+      # @api private
+      # @return [String]
+      def failure_message
+        unless iterable?
+          return "#{improve_hash_formatting(super)}, but was not iterable"
+        end
+
+        all_messages = [improve_hash_formatting(super)]
+        failed_objects.each do |index, matcher_failure_message|
+          all_messages << failure_message_for_item(index, matcher_failure_message)
+        end
+        all_messages.join("\n\n")
+      end
+
+      # @api private
+      # @return [String]
+      def description
+        improve_hash_formatting "include an object #{description_of matcher}"
+      end
+
+      def does_not_match?(actual)
+        @actual = actual
+
+        return false unless iterable?
+
+        index_objects
+
+        any_succeeded_object == false
+      end
+
+      private
+
+      def match(expected, actual)
+        @actual   = actual
+        @expected = expected
+
+        return false unless iterable?
+
+        index_objects
+
+        any_succeeded_object == true
+      end
+
+      def index_objects
+        actual.each_with_index do |actual_item, index|
+          cloned_matcher = matcher.clone
+          begin
+            matches = cloned_matcher.matches?(actual_item)
+          rescue StandardError
+            matches = nil
+          end
+
+          if matches
+            self.any_succeeded_object = true
+            break
+          else
+            failed_objects[index] = cloned_matcher.failure_message
+          end
+        end
+      end
+
+      def failure_message_for_item(index, failure_message)
+        failure_message = indent_multiline_message(add_new_line_if_needed(failure_message))
+        indent_multiline_message("object at index #{index} failed to match:#{failure_message}")
+      end
+
+      def add_new_line_if_needed(message)
+        message.start_with?("\n") ? message : "\n#{message}"
+      end
+
+      def indent_multiline_message(message)
+        message = message.sub(/\n+\z/, '')
+        message.lines.map do |line|
+          line =~ /\S/ ? '   ' + line : line
+        end.join
+      end
+    end
+  end
+end
+
+module RSpec
+  module Matchers
+    # Passes if the provided matcher passes when checked against any
+    # element of the collection.
+    #
+    # @example
+    #   expect([1, 4, 5]).to include_an_object be_odd
+    #
+    # @note You can also use this with compound matchers as well.
+    #
+    # @example
+    #   expect([1, 4, 'a']).to include_an_object( be_odd.and be_an(Integer) )
+    def include_an_object(expected)
+      ::Aruba::Matchers::IncludeAnObject.new(expected)
+    end
+  end
+end

data/lib/aruba/matchers/command/be_successfully_executed.rb

@@ -16,9 +16,9 @@ require 'aruba/matchers/command/have_finished_in_time'
 #   @example Use matcher
 #
 #     RSpec.describe do
-#       it { expect(last_command).to be_successfully_executed }
-#       it { expect(last_command).not_to be_successfully_executed }
-#       it { expect(last_command).to have_failed_running }
+#       it { expect(last_command_started).to be_successfully_executed }
+#       it { expect(last_command_started).not_to be_successfully_executed }
+#       it { expect(last_command_started).to have_failed_running }
 #     end
 RSpec::Matchers.define :be_successfully_executed do
   match do |actual|

data/lib/aruba/matchers/command/have_exit_status.rb

@@ -14,22 +14,13 @@
 #   @example Use matcher
 #
 #     RSpec.describe do
-#       it { expect(last_command).to have_exit_status(0) }
+#       it { expect(last_command_started).to have_exit_status(0) }
 #     end
 RSpec::Matchers.define :have_exit_status do |expected|
   match do |actual|
     @old_actual = actual
 
-    @announcer ||= Aruba::Announcer.new(
-      self,
-      :stdout => @announce_stdout,
-      :stderr => @announce_stderr,
-      :dir    => @announce_dir,
-      :cmd    => @announce_cmd,
-      :env    => @announce_env
-    )
-
-    @old_actual.stop(@announcer) unless @old_actual.stopped?
+    @old_actual.stop(announcer) unless @old_actual.stopped?
     @actual = actual.exit_status
 
     next false unless @old_actual.respond_to? :exit_status

data/lib/aruba/matchers/command/have_finished_in_time.rb

@@ -14,9 +14,9 @@ require 'rspec/expectations/version'
 #   @example Use matcher
 #
 #     RSpec.describe do
-#       it { expect(last_command).to run_too_long }
-#       it { expect(last_command).not_to run_too_long }
-#       it { expect(last_command).to finish_its_run_in_time }
+#       it { expect(last_command_started).to run_too_long }
+#       it { expect(last_command_started).not_to run_too_long }
+#       it { expect(last_command_started).to finish_its_run_in_time }
 #     end
 # RSpec::Matchers.define :run_too_long do
 RSpec::Matchers.define :have_finished_in_time do
@@ -24,6 +24,8 @@ RSpec::Matchers.define :have_finished_in_time do
     @old_actual = actual
     @actual     = @old_actual.commandline
 
+    next false unless @old_actual.respond_to? :timed_out?
+
     @announcer ||= Aruba::Announcer.new(
       self,
       :stdout => @announce_stdout,
@@ -35,8 +37,6 @@ RSpec::Matchers.define :have_finished_in_time do
 
     @old_actual.stop(@announcer) unless @old_actual.stopped?
 
-    next false unless @old_actual.respond_to? :timed_out?
-
     @old_actual.timed_out? == false
   end
 end

data/lib/aruba/matchers/command/have_output.rb

@@ -0,0 +1,46 @@
+# @!method have_output
+#   This matchers checks if <command> has created output
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command has not created output
+#     true:
+#     * if command created output
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output }
+#     end
+RSpec::Matchers.define :have_output do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    next false unless @old_actual.respond_to? :output
+
+    @announcer ||= Aruba::Announcer.new(
+      self,
+      :stdout => @announce_stdout,
+      :stderr => @announce_stderr,
+      :dir    => @announce_dir,
+      :cmd    => @announce_cmd,
+      :env    => @announce_env
+    )
+
+    @old_actual.stop(@announcer) unless @old_actual.stopped?
+
+    @actual = unescape_text(actual.output.chomp)
+    @actual = extract_text(@actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+    values_match?(expected, @actual)
+  end
+
+  diffable
+
+  description { "have output: #{description_of expected}" }
+end
+
+if RSpec::Expectations::Version::STRING >= '3.0'
+  RSpec::Matchers.alias_matcher :a_command_having_output, :have_output
+end

data/lib/aruba/matchers/command/have_output_on_stderr.rb

@@ -0,0 +1,42 @@
+# @!method have_output_on_stderr
+#   This matchers checks if <command> has created output on stderr
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command has not created output on stderr
+#     true:
+#     * if command created output on stderr
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output_on_stderr }
+#     end
+RSpec::Matchers.define :have_output_on_stderr do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    next false unless @old_actual.respond_to? :stderr
+
+    @announcer ||= Aruba::Announcer.new(
+      self,
+      :stdout => @announce_stdout,
+      :stderr => @announce_stderr,
+      :dir    => @announce_dir,
+      :cmd    => @announce_cmd,
+      :env    => @announce_env
+    )
+
+    @old_actual.stop(@announcer) unless @old_actual.stopped?
+
+    @actual = unescape_text(actual.stderr.chomp)
+    @actual = extract_text(@actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+    values_match?(expected, @actual)
+  end
+
+  diffable
+
+  description { "have output on stderr: #{description_of expected}" }
+end

data/lib/aruba/matchers/command/have_output_on_stdout.rb

@@ -0,0 +1,42 @@
+# @!method have_output_on_stdout
+#   This matchers checks if <command> has created output on stdout
+#
+#   @return [TrueClass, FalseClass] The result
+#
+#     false:
+#     * if command has not created output on stdout
+#     true:
+#     * if command created output on stdout
+#
+#   @example Use matcher
+#
+#     RSpec.describe do
+#       it { expect(last_command_started).to have_output_on_stdout }
+#     end
+RSpec::Matchers.define :have_output_on_stdout do |expected|
+  match do |actual|
+    @old_actual = actual
+
+    next false unless @old_actual.respond_to? :stdout
+
+    @announcer ||= Aruba::Announcer.new(
+      self,
+      :stdout => @announce_stdout,
+      :stderr => @announce_stderr,
+      :dir    => @announce_dir,
+      :cmd    => @announce_cmd,
+      :env    => @announce_env
+    )
+
+    @old_actual.stop(@announcer) unless @old_actual.stopped?
+
+    @actual = unescape_text(actual.stdout.chomp)
+    @actual = extract_text(@actual) if !aruba.config.keep_ansi || aruba.config.remove_ansi_escape_sequences
+
+    values_match?(expected, @actual)
+  end
+
+  diffable
+
+  description { "have output on stdout: #{description_of expected}" }
+end