rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

metadata.gz.sig

@@ -1,4 +1,3 @@
-���ެ��M���fQ��Ƽ��V��4���A"	5�f���G&ʱD+w���
-p>v�^4R-�)N�J�g�G�<���
-�UŽ�^���b'�
-i�������Ĩ�ik9�gu��@�5?a��Ejdڳ*:�)�WL�B�i�g�2q �GF��D?�UN|*�����/�|�>)�gMkĺ��<؛tZ
+��5>u��-c�rEJ�
+��؁'���{���J���Ncc�K� j��5��'���Մ�8z���2br��f��G�.R�p�H���ա�P(����^�1GNw�'W 2~�~�U�ӖE��ò\W VF�G�
+���"�-���g��3�

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZTQwOGIzZDdiMmUzMGI5OWQ2NmQzOTBjYmJiZTUzODkyYTAxOGM2YQ==
-  data.tar.gz: !binary |-
-    YzI4OTM1NjI1ZDRiZTRkYjY3NTJkMTMzMThkMWY3OTY2OWE2MDFiNQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    ODFmYzI4Mjk1MTVmMjYyMjc0NzBiNTE4YTc2MjE2ZjZiMDhhODBlN2Q3ZmZm
-    MWFmMzU4NTkxOWZiMTczYzgzMWI5NzU5MTM5M2IyYjBkYmUxNGQ5ZDM0YjVm
-    MGJjMWY1ODY4MjU5ZDZmODdmOTY4MzZkMDEzNmI5Y2I5YjljNzM=
-  data.tar.gz: !binary |-
-    MjA3YWZlNjdmOTA4YzRhYmVjODQ5MDUzMzIxNTJhMTFmMmQwZTk1MTQ3OGM2
-    OTNmYjI1NjhlZDMxNDU0NTlhNjljNWQ2ZWE4MTI3YWQzYjA3N2JmZmViNmY1
-    MThhZWNkNzZmOGJmY2M3MDBjNDQzMjJmOTkwZDAyZTlhZDJkMjc=

data/features/built_in_matchers/match_array.feature

@@ -1,37 +0,0 @@
-Feature: match_array matcher
-
-  The `match_array` matcher provides a way to test arrays against each other
-  in a way that disregards differences in the ordering between the actual
-  and expected array. For example:
-
-    ```ruby
-    expect([1, 2, 3]).to    match_array [2, 3, 1] # pass
-    expect([:a, :c, :b]).to match_array [:a, :c]  # fail
-    ```
-
-  Scenario: array operator matchers
-    Given a file named "array_operator_matchers_spec.rb" with:
-      """ruby
-      describe do
-        example { expect([1, 2, 3]).to match_array [1, 2, 3] }
-        example { expect([1, 2, 3]).to match_array [1, 3, 2] }
-        example { expect([1, 2, 3]).to match_array [2, 1, 3] }
-        example { expect([1, 2, 3]).to match_array [2, 3, 1] }
-        example { expect([1, 2, 3]).to match_array [3, 1, 2] }
-        example { expect([1, 2, 3]).to match_array [3, 2, 1] }
-
-        # deliberate failures
-        example { expect([1, 2, 3]).to match_array [1, 2, 1] }
-      end
-      """
-     When I run `rspec array_operator_matchers_spec.rb`
-     Then the output should contain "7 examples, 1 failure"
-      And the output should contain:
-      """
-           Failure/Error: example { expect([1, 2, 3]).to match_array [1, 2, 1] }
-             expected collection contained:  [1, 1, 2]
-             actual collection contained:    [1, 2, 3]
-             the missing elements were:      [1]
-             the extra elements were:        [3]
-      """
-

data/lib/rspec/expectations/errors.rb

@@ -1,9 +0,0 @@
-module RSpec
-  module Expectations
-    if defined?(Test::Unit::AssertionFailedError)
-      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
-    else
-      class ExpectationNotMetError < ::StandardError; end
-    end
-  end
-end

data/lib/rspec/expectations/extensions.rb

@@ -1 +0,0 @@
-require 'rspec/expectations/extensions/object'

data/lib/rspec/expectations/extensions/object.rb

@@ -1,29 +0,0 @@
-module RSpec
-  module Expectations
-    module DeprecatedConstants
-      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
-      # delegates to super.
-      def const_missing(name)
-        case name
-        when :Rspec, :Spec
-          RSpec.deprecate(name.to_s, :replacement => "RSpec")
-          RSpec
-        else
-          begin
-            super
-          rescue Exception => e
-            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
-            raise e
-          end
-        end
-      end
-    end
-
-    # @deprecated (no replacement)
-    def differ=(ignore)
-      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
-    end
-  end
-end
-
-extend RSpec::Expectations::DeprecatedConstants

data/lib/rspec/matchers/built_in/match_array.rb

@@ -1,51 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      class MatchArray < BaseMatcher
-        def match(expected, actual)
-          return false unless actual.respond_to? :to_ary
-          @extra_items = difference_between_arrays(actual, expected)
-          @missing_items = difference_between_arrays(expected, actual)
-          @extra_items.empty? & @missing_items.empty?
-        end
-
-        def failure_message_for_should
-          if actual.respond_to? :to_ary
-            message =  "expected collection contained:  #{safe_sort(expected).inspect}\n"
-            message += "actual collection contained:    #{safe_sort(actual).inspect}\n"
-            message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
-            message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
-          else
-            message = "expected an array, actual collection was #{actual.inspect}"
-          end
-
-          message
-        end
-
-        def failure_message_for_should_not
-          "Matcher does not support should_not"
-        end
-
-        def description
-          "contain exactly #{_pretty_print(expected)}"
-        end
-
-        private
-
-        def safe_sort(array)
-          array.sort rescue array
-        end
-
-        def difference_between_arrays(array_1, array_2)
-          difference = array_1.to_ary.dup
-          array_2.to_ary.each do |element|
-            if index = difference.index(element)
-              difference.delete_at(index)
-            end
-          end
-          difference
-        end
-      end
-    end
-  end
-end

data/lib/rspec/matchers/compatibility.rb

@@ -1,14 +0,0 @@
-RSpec::Matchers.constants.each do |c|
-  if Class === (klass = RSpec::Matchers.const_get(c))
-    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
-      klass.class_exec do
-        alias_method :failure_message, :failure_message_for_should
-      end
-    end
-    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
-      klass.class_exec do
-        alias_method :negative_failure_message, :failure_message_for_should_not
-      end
-    end
-  end
-end

data/lib/rspec/matchers/matcher.rb

@@ -1,301 +0,0 @@
-require 'set'
-
-module RSpec
-  module Matchers
-    module DSL
-      # Contains the methods that are available from within the
-      # `RSpec::Matchers.define` DSL for creating custom matchers.
-      module Macros
-        # Stores the block that is used to determine whether this matcher passes
-        # or fails. The block should return a boolean value. When the matcher is
-        # passed to `expect(...).to` and the block returns `true`, then the expectation
-        # passes. Similarly, when the matcher is passed to `expect(...).not_to` and the
-        # block returns `false`, then the expectation passes.
-        #
-        # Use `match_for_should` when used in conjunction with
-        # `match_for_should_not`.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :be_even do
-        #       match do |actual|
-        #         actual.even?
-        #       end
-        #     end
-        #
-        #     expect(4).to be_even     # passes
-        #     expect(3).not_to be_even # passes
-        #     expect(3).to be_even     # fails
-        #     expect(4).not_to be_even # fails
-        #
-        # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
-        def match(&match_block)
-          define_user_override(:matches?, match_block) do |actual|
-            begin
-              @actual = actual
-              super(*actual_arg_for(match_block))
-            rescue RSpec::Expectations::ExpectationNotMetError
-              false
-            end
-          end
-        end
-        alias match_for_should match
-
-        # Use this to define the block for a negative expectation (`expect(...).not_to`)
-        # when the positive and negative forms require different handling. This
-        # is rarely necessary, but can be helpful, for example, when specifying
-        # asynchronous processes that require different timeouts.
-        #
-        # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
-        def match_for_should_not(&match_block)
-          define_user_override(:does_not_match?, match_block) do |actual|
-            @actual = actual
-            super(*actual_arg_for(match_block))
-          end
-        end
-
-        # Use this instead of `match` when the block will raise an exception
-        # rather than returning false to indicate a failure.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
-        #       match_unless_raises ValidationException do |validator|
-        #         validator.validate(candidate_address)
-        #       end
-        #     end
-        #
-        #     expect(email_validator).to accept_as_valid("person@company.com")
-        #
-        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
-        def match_unless_raises(expected_exception=Exception, &match_block)
-          define_user_override(:matches?, match_block) do |actual|
-            @actual = actual
-            begin
-              super(*actual_arg_for(match_block))
-            rescue expected_exception => @rescued_exception
-              false
-            else
-              true
-            end
-          end
-        end
-
-        # Customizes the failure messsage to use when this matcher is
-        # asked to positively match. Only use this when the message
-        # generated by default doesn't suit your needs.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :have_strength do |expected|
-        #       match { your_match_logic }
-        #
-        #       failure_message_for_should do |actual|
-        #         "Expected strength of #{expected}, but had #{actual.strength}"
-        #       end
-        #     end
-        #
-        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
-        def failure_message_for_should(&definition)
-          define_user_override(__method__, definition)
-        end
-
-        # Customize the failure messsage to use when this matcher is asked
-        # to negatively match. Only use this when the message generated by
-        # default doesn't suit your needs.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :have_strength do |expected|
-        #       match { your_match_logic }
-        #
-        #       failure_message_for_should_not do |actual|
-        #         "Expected not to have strength of #{expected}, but did"
-        #       end
-        #     end
-        #
-        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
-        def failure_message_for_should_not(&definition)
-          define_user_override(__method__, definition)
-        end
-
-        # Customize the description to use for one-liners.  Only use this when
-        # the description generated by default doesn't suit your needs.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :qualify_for do |expected|
-        #       match { your_match_logic }
-        #
-        #       description do
-        #         "qualify for #{expected}"
-        #       end
-        #     end
-        #
-        # @yield [Object] actual the actual object (i.e. the value wrapped by `expect`)
-        def description(&definition)
-          define_user_override(__method__, definition)
-        end
-
-        # Tells the matcher to diff the actual and expected values in the failure
-        # message.
-        def diffable
-          define_method(:diffable?) { true }
-        end
-
-        # Convenience for defining methods on this matcher to create a fluent
-        # interface. The trick about fluent interfaces is that each method must
-        # return self in order to chain methods together. `chain` handles that
-        # for you.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :have_errors_on do |key|
-        #       chain :with do |message|
-        #         @message = message
-        #       end
-        #
-        #       match do |actual|
-        #         actual.errors[key] == @message
-        #       end
-        #     end
-        #
-        #     expect(minor).to have_errors_on(:age).with("Not old enough to participate")
-        def chain(name, &definition)
-          define_user_override(name, definition) do |*args, &block|
-            super(*args, &block)
-            self
-          end
-        end
-
-      private
-
-        # Does the following:
-        #
-        # - Defines the named method usign a user-provided block
-        #   in @user_method_defs, which is included as an ancestor
-        #   in the singleton class in which we eval the `define` block.
-        # - Defines an overriden definition for the same method
-        #   usign the provided `our_def` block.
-        # - Provides a default `our_def` block for the common case
-        #   of needing to call the user's definition with `@actual`
-        #   as an arg, but only if their block's arity can handle it.
-        #
-        # This compiles the user block into an actual method, allowing
-        # them to use normal method constructs like `return`
-        # (e.g. for a early guard statement), while allowing us to define
-        # an override that can provide the wrapped handling
-        # (e.g. assigning `@actual`, rescueing errors, etc) and
-        # can `super` to the user's definition.
-        def define_user_override(method_name, user_def, &our_def)
-          @user_method_defs.__send__(:define_method, method_name, &user_def)
-          our_def ||= lambda { super(*actual_arg_for(user_def)) }
-          define_method(method_name, &our_def)
-        end
-      end
-
-      # Defines default implementations of the matcher
-      # protocol methods for custom matchers. You can
-      # override any of these using the {RSpec::Matchers::DSL::Macros Macros} methods
-      # from within an `RSpec::Matchers.define` block.
-      module DefaultImplementations
-        # @api private
-        # Used internally by objects returns by `should` and `should_not`.
-        def diffable?
-          false
-        end
-
-        # The default description.
-        def description
-          "#{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        # The default failure message for positive expectations.
-        def failure_message_for_should
-          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        # The default failure message for negative expectations.
-        def failure_message_for_should_not
-          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
-        end
-      end
-
-      # The class used for custom matchers. The block passed to
-      # `RSpec::Matchers.define` will be evaluated in the context
-      # of the singleton class of an instance, and will have the
-      # {RSpec::Matchers::DSL::Macros Macros} methods available.
-      class Matcher
-        # Provides default implementations for the matcher protocol methods.
-        include DefaultImplementations
-
-        # Allows expectation expressions to be used in the match block.
-        include RSpec::Matchers
-
-        # Converts matcher name and expected args to an English expresion.
-        include RSpec::Matchers::Pretty
-
-        # Makes the macro methods available to an `RSpec::Matchers.define` block.
-        extend Macros
-
-        attr_reader   :expected, :actual, :rescued_exception
-        attr_accessor :matcher_execution_context
-
-        # @api private
-        def initialize(name, declarations, *expected)
-          @name     = name
-          @actual   = nil
-          @expected = expected
-
-          class << self
-            # See `Macros#define_user_override` above, for an explanation.
-            include(@user_method_defs = Module.new)
-            self
-          end.class_exec(*expected, &declarations)
-        end
-
-        # Adds the name (rather than a cryptic hex number)
-        # so we can identify an instance of
-        # the matcher in error messages (e.g. for `NoMethodError`)
-        def inspect
-          "#<#{self.class.name} #{name}>"
-        end
-
-        if RUBY_VERSION.to_f >= 1.9
-          # Indicates that this matcher responds to messages
-          # from the `matcher_execution_context` as well.
-          # Also, supports getting a method object for such methods.
-          def respond_to_missing?(method, include_private=false)
-            super || matcher_execution_context.respond_to?(method, include_private)
-          end
-        else # for 1.8.7
-          # Indicates that this matcher responds to messages
-          # from the `matcher_execution_context` as well.
-          def respond_to?(method, include_private=false)
-            super || matcher_execution_context.respond_to?(method, include_private)
-          end
-        end
-
-      private
-
-        def actual_arg_for(block)
-          block.arity.zero? ? [] : [@actual]
-        end
-
-        # Takes care of forwarding unhandled messages to the
-        # `matcher_execution_context` (typically the current
-        # running `RSpec::Core::Example`). This is needed by
-        # rspec-rails so that it can define matchers that wrap
-        # Rails' test helper methods, but it's also a useful
-        # feature in its own right.
-        def method_missing(method, *args, &block)
-          if matcher_execution_context.respond_to?(method)
-            matcher_execution_context.__send__ method, *args, &block
-          else
-            super(method, *args, &block)
-          end
-        end
-      end
-    end
-  end
-end