cloudsmith-api 0.44.4 → 0.49.9

data/vendor/bundle/ruby/2.3.0/gems/rspec-expectations-3.8.4/lib/rspec/matchers/built_in/compound.rb

@@ -1,271 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Base class for `and` and `or` compound matchers.
-      class Compound < BaseMatcher
-        # @private
-        attr_reader :matcher_1, :matcher_2, :evaluator
-
-        def initialize(matcher_1, matcher_2)
-          @matcher_1 = matcher_1
-          @matcher_2 = matcher_2
-        end
-
-        # @private
-        def does_not_match?(_actual)
-          raise NotImplementedError, "`expect(...).not_to matcher.#{conjunction} matcher` " \
-            "is not supported, since it creates a bit of an ambiguity. Instead, define negated versions " \
-            "of whatever matchers you wish to negate with `RSpec::Matchers.define_negated_matcher` and " \
-            "use `expect(...).to matcher.#{conjunction} matcher`."
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{matcher_1.description} #{conjunction} #{matcher_2.description}"
-        end
-
-        def supports_block_expectations?
-          matcher_supports_block_expectations?(matcher_1) &&
-          matcher_supports_block_expectations?(matcher_2)
-        end
-
-        def expects_call_stack_jump?
-          NestedEvaluator.matcher_expects_call_stack_jump?(matcher_1) ||
-          NestedEvaluator.matcher_expects_call_stack_jump?(matcher_2)
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          matcher_is_diffable?(matcher_1) || matcher_is_diffable?(matcher_2)
-        end
-
-        # @api private
-        # @return [RSpec::Matchers::ExpectedsForMultipleDiffs]
-        def expected
-          return nil unless evaluator
-          ::RSpec::Matchers::ExpectedsForMultipleDiffs.for_many_matchers(diffable_matcher_list)
-        end
-
-      protected
-
-        def diffable_matcher_list
-          list = []
-          list.concat(diffable_matcher_list_for(matcher_1)) unless matcher_1_matches?
-          list.concat(diffable_matcher_list_for(matcher_2)) unless matcher_2_matches?
-          list
-        end
-
-      private
-
-        def initialize_copy(other)
-          @matcher_1 = @matcher_1.clone
-          @matcher_2 = @matcher_2.clone
-          super
-        end
-
-        def match(_expected, actual)
-          evaluator_klass = if supports_block_expectations? && Proc === actual
-                              NestedEvaluator
-                            else
-                              SequentialEvaluator
-                            end
-
-          @evaluator = evaluator_klass.new(actual, matcher_1, matcher_2)
-        end
-
-        def indent_multiline_message(message)
-          message.lines.map do |line|
-            line =~ /\S/ ? '   ' + line : line
-          end.join
-        end
-
-        def compound_failure_message
-          "#{indent_multiline_message(matcher_1.failure_message.sub(/\n+\z/, ''))}" \
-          "\n\n...#{conjunction}:" \
-          "\n\n#{indent_multiline_message(matcher_2.failure_message.sub(/\A\n+/, ''))}"
-        end
-
-        def matcher_1_matches?
-          evaluator.matcher_matches?(matcher_1)
-        end
-
-        def matcher_2_matches?
-          evaluator.matcher_matches?(matcher_2)
-        end
-
-        def matcher_supports_block_expectations?(matcher)
-          matcher.supports_block_expectations?
-        rescue NoMethodError
-          false
-        end
-
-        def matcher_is_diffable?(matcher)
-          matcher.diffable?
-        rescue NoMethodError
-          false
-        end
-
-        def diffable_matcher_list_for(matcher)
-          return [] unless matcher_is_diffable?(matcher)
-          return matcher.diffable_matcher_list if Compound === matcher
-          [matcher]
-        end
-
-        # For value expectations, we can evaluate the matchers sequentially.
-        class SequentialEvaluator
-          def initialize(actual, *)
-            @actual = actual
-          end
-
-          def matcher_matches?(matcher)
-            matcher.matches?(@actual)
-          end
-        end
-
-        # Normally, we evaluate the matching sequentially. For an expression like
-        # `expect(x).to foo.and bar`, this becomes:
-        #
-        #   expect(x).to foo
-        #   expect(x).to bar
-        #
-        # For block expectations, we need to nest them instead, so that
-        # `expect { x }.to foo.and bar` becomes:
-        #
-        #   expect {
-        #     expect { x }.to foo
-        #   }.to bar
-        #
-        # This is necessary so that the `expect` block is only executed once.
-        class NestedEvaluator
-          def initialize(actual, matcher_1, matcher_2)
-            @actual        = actual
-            @matcher_1     = matcher_1
-            @matcher_2     = matcher_2
-            @match_results = {}
-
-            inner, outer = order_block_matchers
-
-            @match_results[outer] = outer.matches?(Proc.new do |*args|
-              @match_results[inner] = inner.matches?(inner_matcher_block(args))
-            end)
-          end
-
-          def matcher_matches?(matcher)
-            @match_results.fetch(matcher)
-          end
-
-        private
-
-          # Some block matchers (such as `yield_xyz`) pass args to the `expect` block.
-          # When such a matcher is used as the outer matcher, we need to forward the
-          # the args on to the `expect` block.
-          def inner_matcher_block(outer_args)
-            return @actual if outer_args.empty?
-
-            Proc.new do |*inner_args|
-              unless inner_args.empty?
-                raise ArgumentError, "(#{@matcher_1.description}) and " \
-                  "(#{@matcher_2.description}) cannot be combined in a compound expectation " \
-                  "since both matchers pass arguments to the block."
-              end
-
-              @actual.call(*outer_args)
-            end
-          end
-
-          # For a matcher like `raise_error` or `throw_symbol`, where the block will jump
-          # up the call stack, we need to order things so that it is the inner matcher.
-          # For example, we need it to be this:
-          #
-          #   expect {
-          #     expect {
-          #       x += 1
-          #       raise "boom"
-          #     }.to raise_error("boom")
-          #   }.to change { x }.by(1)
-          #
-          # ...rather than:
-          #
-          #   expect {
-          #     expect {
-          #       x += 1
-          #       raise "boom"
-          #     }.to change { x }.by(1)
-          #   }.to raise_error("boom")
-          #
-          # In the latter case, the after-block logic in the `change` matcher would never
-          # get executed because the `raise "boom"` line would jump to the `rescue` in the
-          # `raise_error` logic, so only the former case will work properly.
-          #
-          # This method figures out which matcher should be the inner matcher and which
-          # should be the outer matcher.
-          def order_block_matchers
-            return @matcher_1, @matcher_2 unless self.class.matcher_expects_call_stack_jump?(@matcher_2)
-            return @matcher_2, @matcher_1 unless self.class.matcher_expects_call_stack_jump?(@matcher_1)
-
-            raise ArgumentError, "(#{@matcher_1.description}) and " \
-              "(#{@matcher_2.description}) cannot be combined in a compound expectation " \
-              "because they both expect a call stack jump."
-          end
-
-          def self.matcher_expects_call_stack_jump?(matcher)
-            matcher.expects_call_stack_jump?
-          rescue NoMethodError
-            false
-          end
-        end
-
-        # @api public
-        # Matcher used to represent a compound `and` expectation.
-        class And < self
-          # @api private
-          # @return [String]
-          def failure_message
-            if matcher_1_matches?
-              matcher_2.failure_message
-            elsif matcher_2_matches?
-              matcher_1.failure_message
-            else
-              compound_failure_message
-            end
-          end
-
-        private
-
-          def match(*)
-            super
-            matcher_1_matches? && matcher_2_matches?
-          end
-
-          def conjunction
-            "and"
-          end
-        end
-
-        # @api public
-        # Matcher used to represent a compound `or` expectation.
-        class Or < self
-          # @api private
-          # @return [String]
-          def failure_message
-            compound_failure_message
-          end
-
-        private
-
-          def match(*)
-            super
-            matcher_1_matches? || matcher_2_matches?
-          end
-
-          def conjunction
-            "or"
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rspec-expectations-3.8.4/lib/rspec/matchers/built_in/respond_to.rb

@@ -1,165 +0,0 @@
-RSpec::Support.require_rspec_support "method_signature_verifier"
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `respond_to`.
-      # Not intended to be instantiated directly.
-      class RespondTo < BaseMatcher
-        def initialize(*names)
-          @names = names
-          @expected_arity = nil
-          @expected_keywords = []
-          @unlimited_arguments = nil
-          @arbitrary_keywords = nil
-        end
-
-        # @api public
-        # Specifies the number of expected arguments.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with(3).arguments
-        def with(n)
-          @expected_arity = n
-          self
-        end
-
-        # @api public
-        # Specifies keyword arguments, if any.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with_keywords(:color, :shape)
-        # @example with an expected number of arguments
-        #   expect(obj).to respond_to(:message).with(3).arguments.and_keywords(:color, :shape)
-        def with_keywords(*keywords)
-          @expected_keywords = keywords
-          self
-        end
-        alias :and_keywords :with_keywords
-
-        # @api public
-        # Specifies that the method accepts any keyword, i.e. the method has
-        #   a splatted keyword parameter of the form **kw_args.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with_any_keywords
-        def with_any_keywords
-          @arbitrary_keywords = true
-          self
-        end
-        alias :and_any_keywords :with_any_keywords
-
-        # @api public
-        # Specifies that the number of arguments has no upper limit, i.e. the
-        #   method has a splatted parameter of the form *args.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with_unlimited_arguments
-        def with_unlimited_arguments
-          @unlimited_arguments = true
-          self
-        end
-        alias :and_unlimited_arguments :with_unlimited_arguments
-
-        # @api public
-        # No-op. Intended to be used as syntactic sugar when using `with`.
-        #
-        # @example
-        #   expect(obj).to respond_to(:message).with(3).arguments
-        def argument
-          self
-        end
-        alias :arguments :argument
-
-        # @private
-        def matches?(actual)
-          find_failing_method_names(actual, :reject).empty?
-        end
-
-        # @private
-        def does_not_match?(actual)
-          find_failing_method_names(actual, :select).empty?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to respond to #{@failing_method_names.map { |name| description_of(name) }.join(', ')}#{with_arity}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message.sub(/to respond to/, 'not to respond to')
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "respond to #{pp_names}#{with_arity}"
-        end
-
-      private
-
-        def find_failing_method_names(actual, filter_method)
-          @actual = actual
-          @failing_method_names = @names.__send__(filter_method) do |name|
-            @actual.respond_to?(name) && matches_arity?(actual, name)
-          end
-        end
-
-        def matches_arity?(actual, name)
-          expectation = Support::MethodSignatureExpectation.new
-
-          if @expected_arity.is_a?(Range)
-            expectation.min_count = @expected_arity.min
-            expectation.max_count = @expected_arity.max
-          else
-            expectation.min_count = @expected_arity
-          end
-
-          expectation.keywords = @expected_keywords
-          expectation.expect_unlimited_arguments = @unlimited_arguments
-          expectation.expect_arbitrary_keywords  = @arbitrary_keywords
-
-          return true if expectation.empty?
-
-          signature = Support::MethodSignature.new(Support.method_handle_for(actual, name))
-
-          Support::StrictSignatureVerifier.new(signature).with_expectation(expectation).valid?
-        end
-
-        def with_arity
-          str = ''.dup
-          str << " with #{with_arity_string}" if @expected_arity
-          str << " #{str.length == 0 ? 'with' : 'and'} #{with_keywords_string}" if @expected_keywords && @expected_keywords.count > 0
-          str << " #{str.length == 0 ? 'with' : 'and'} unlimited arguments" if @unlimited_arguments
-          str << " #{str.length == 0 ? 'with' : 'and'} any keywords" if @arbitrary_keywords
-          str
-        end
-
-        def with_arity_string
-          "#{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
-        end
-
-        def with_keywords_string
-          kw_str = case @expected_keywords.count
-                   when 1
-                     @expected_keywords.first.inspect
-                   when 2
-                     @expected_keywords.map(&:inspect).join(' and ')
-                   else
-                     "#{@expected_keywords[0...-1].map(&:inspect).join(', ')}, and #{@expected_keywords.last.inspect}"
-                   end
-
-          "keyword#{@expected_keywords.count == 1 ? '' : 's'} #{kw_str}"
-        end
-
-        def pp_names
-          @names.length == 1 ? "##{@names.first}" : description_of(@names)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rspec-expectations-3.8.4/lib/rspec/matchers/dsl.rb

@@ -1,527 +0,0 @@
-module RSpec
-  module Matchers
-    # Defines the custom matcher DSL.
-    module DSL
-      # Defines a matcher alias. The returned matcher's `description` will be overriden
-      # to reflect the phrasing of the new name, which will be used in failure messages
-      # when passed as an argument to another matcher in a composed matcher expression.
-      #
-      # @example
-      #   RSpec::Matchers.alias_matcher :a_list_that_sums_to, :sum_to
-      #   sum_to(3).description # => "sum to 3"
-      #   a_list_that_sums_to(3).description # => "a list that sums to 3"
-      #
-      # @example
-      #   RSpec::Matchers.alias_matcher :a_list_sorted_by, :be_sorted_by do |description|
-      #     description.sub("be sorted by", "a list sorted by")
-      #   end
-      #
-      #   be_sorted_by(:age).description # => "be sorted by age"
-      #   a_list_sorted_by(:age).description # => "a list sorted by age"
-      #
-      # @param new_name [Symbol] the new name for the matcher
-      # @param old_name [Symbol] the original name for the matcher
-      # @param options  [Hash] options for the aliased matcher
-      # @option options [Class] :klass the ruby class to use as the decorator. (Not normally used).
-      # @yield [String] optional block that, when given, is used to define the overriden
-      #   logic. The yielded arg is the original description or failure message. If no
-      #   block is provided, a default override is used based on the old and new names.
-      # @see RSpec::Matchers
-      def alias_matcher(new_name, old_name, options={}, &description_override)
-        description_override ||= lambda do |old_desc|
-          old_desc.gsub(EnglishPhrasing.split_words(old_name), EnglishPhrasing.split_words(new_name))
-        end
-        klass = options.fetch(:klass) { AliasedMatcher }
-
-        define_method(new_name) do |*args, &block|
-          matcher = __send__(old_name, *args, &block)
-          matcher.matcher_name = new_name if matcher.respond_to?(:matcher_name=)
-          klass.new(matcher, description_override)
-        end
-      end
-
-      # Defines a negated matcher. The returned matcher's `description` and `failure_message`
-      # will be overriden to reflect the phrasing of the new name, and the match logic will
-      # be based on the original matcher but negated.
-      #
-      # @example
-      #   RSpec::Matchers.define_negated_matcher :exclude, :include
-      #   include(1, 2).description # => "include 1 and 2"
-      #   exclude(1, 2).description # => "exclude 1 and 2"
-      #
-      # @param negated_name [Symbol] the name for the negated matcher
-      # @param base_name [Symbol] the name of the original matcher that will be negated
-      # @yield [String] optional block that, when given, is used to define the overriden
-      #   logic. The yielded arg is the original description or failure message. If no
-      #   block is provided, a default override is used based on the old and new names.
-      # @see RSpec::Matchers
-      def define_negated_matcher(negated_name, base_name, &description_override)
-        alias_matcher(negated_name, base_name, :klass => AliasedNegatedMatcher, &description_override)
-      end
-
-      # Defines a custom matcher.
-      #
-      # @param name [Symbol] the name for the matcher
-      # @yield [Object] block that is used to define the matcher.
-      #   The block is evaluated in the context of your custom matcher class.
-      #   When args are passed to your matcher, they will be yielded here,
-      #   usually representing the expected value(s).
-      # @see RSpec::Matchers
-      def define(name, &declarations)
-        warn_about_block_args(name, declarations)
-        define_method name do |*expected, &block_arg|
-          RSpec::Matchers::DSL::Matcher.new(name, declarations, self, *expected, &block_arg)
-        end
-      end
-      alias_method :matcher, :define
-
-    private
-
-      if Proc.method_defined?(:parameters)
-        def warn_about_block_args(name, declarations)
-          declarations.parameters.each do |type, arg_name|
-            next unless type == :block
-            RSpec.warning("Your `#{name}` custom matcher receives a block argument (`#{arg_name}`), " \
-                          "but due to limitations in ruby, RSpec cannot provide the block. Instead, " \
-                          "use the `block_arg` method to access the block")
-          end
-        end
-      else
-        # :nocov:
-        def warn_about_block_args(*)
-          # There's no way to detect block params on 1.8 since the method reflection APIs don't expose it
-        end
-        # :nocov:
-      end
-
-      RSpec.configure { |c| c.extend self } if RSpec.respond_to?(:configure)
-
-      # 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.
-        #
-        # @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
-        #
-        # By default the match block will swallow expectation errors (e.g.
-        # caused by using an expectation such as `expect(1).to eq 2`), if you
-        # with to allow these to bubble up, pass in the option
-        # `:notify_expectation_failures => true`.
-        #
-        # @param [Hash] options for defining the behavior of the match block.
-        # @yield [Object] actual the actual value (i.e. the value wrapped by `expect`)
-        def match(options={}, &match_block)
-          define_user_override(:matches?, match_block) do |actual|
-            @actual = actual
-            RSpec::Support.with_failure_notifier(RAISE_NOTIFIER) do
-              begin
-                super(*actual_arg_for(match_block))
-              rescue RSpec::Expectations::ExpectationNotMetError
-                raise if options[:notify_expectation_failures]
-                false
-              end
-            end
-          end
-        end
-
-        # @private
-        RAISE_NOTIFIER = Proc.new { |err, _opts| raise err }
-
-        # 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_when_negated(&match_block)
-          define_user_override(:does_not_match?, match_block) do |actual|
-            begin
-              @actual = actual
-              RSpec::Support.with_failure_notifier(RAISE_NOTIFIER) do
-                super(*actual_arg_for(match_block))
-              end
-            rescue RSpec::Expectations::ExpectationNotMetError
-              false
-            end
-          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 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(&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_when_negated 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_when_negated(&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
-
-        # Declares that the matcher can be used in a block expectation.
-        # Users will not be able to use your matcher in a block
-        # expectation without declaring this.
-        # (e.g. `expect { do_something }.to matcher`).
-        def supports_block_expectations
-          define_method(:supports_block_expectations?) { 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. If the method is invoked and the
-        # `include_chain_clauses_in_custom_matcher_descriptions` config option
-        # hash been enabled, the chained method name and args will be added to the
-        # default description and failure message.
-        #
-        # In the common case where you just want the chained method to store some
-        # value(s) for later use (e.g. in `match`), you can provide one or more
-        # attribute names instead of a block; the chained method will store its
-        # arguments in instance variables with those names, and the values will
-        # be exposed via getters.
-        #
-        # @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(method_name, *attr_names, &definition)
-          unless block_given? ^ attr_names.any?
-            raise ArgumentError, "You must pass either a block or some attribute names (but not both) to `chain`."
-          end
-
-          definition = assign_attributes(attr_names) if attr_names.any?
-
-          define_user_override(method_name, definition) do |*args, &block|
-            super(*args, &block)
-            @chained_method_clauses.push([method_name, args])
-            self
-          end
-        end
-
-        def assign_attributes(attr_names)
-          attr_reader(*attr_names)
-          private(*attr_names)
-
-          lambda do |*attr_values|
-            attr_names.zip(attr_values) do |attr_name, attr_value|
-              instance_variable_set(:"@#{attr_name}", attr_value)
-            end
-          end
-        end
-
-        # assign_attributes isn't defined in the private section below because
-        # that makes MRI 1.9.2 emit a warning about private attributes.
-        private :assign_attributes
-
-      private
-
-        # Does the following:
-        #
-        # - Defines the named method using 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 an 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
-
-        # Defines deprecated macro methods from RSpec 2 for backwards compatibility.
-        # @deprecated Use the methods from {Macros} instead.
-        module Deprecated
-          # @deprecated Use {Macros#match} instead.
-          def match_for_should(&definition)
-            RSpec.deprecate("`match_for_should`", :replacement => "`match`")
-            match(&definition)
-          end
-
-          # @deprecated Use {Macros#match_when_negated} instead.
-          def match_for_should_not(&definition)
-            RSpec.deprecate("`match_for_should_not`", :replacement => "`match_when_negated`")
-            match_when_negated(&definition)
-          end
-
-          # @deprecated Use {Macros#failure_message} instead.
-          def failure_message_for_should(&definition)
-            RSpec.deprecate("`failure_message_for_should`", :replacement => "`failure_message`")
-            failure_message(&definition)
-          end
-
-          # @deprecated Use {Macros#failure_message_when_negated} instead.
-          def failure_message_for_should_not(&definition)
-            RSpec.deprecate("`failure_message_for_should_not`", :replacement => "`failure_message_when_negated`")
-            failure_message_when_negated(&definition)
-          end
-        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
-        include BuiltIn::BaseMatcher::DefaultFailureMessages
-
-        # @api private
-        # Used internally by objects returns by `should` and `should_not`.
-        def diffable?
-          false
-        end
-
-        # The default description.
-        def description
-          english_name = EnglishPhrasing.split_words(name)
-          expected_list = EnglishPhrasing.list(expected)
-          "#{english_name}#{expected_list}#{chained_method_clause_sentences}"
-        end
-
-        # Matchers do not support block expectations by default. You
-        # must opt-in.
-        def supports_block_expectations?
-          false
-        end
-
-        # Most matchers do not expect call stack jumps.
-        def expects_call_stack_jump?
-          false
-        end
-
-      private
-
-        def chained_method_clause_sentences
-          return '' unless Expectations.configuration.include_chain_clauses_in_custom_matcher_descriptions?
-
-          @chained_method_clauses.map do |(method_name, method_args)|
-            english_name = EnglishPhrasing.split_words(method_name)
-            arg_list = EnglishPhrasing.list(method_args)
-            " #{english_name}#{arg_list}"
-          end.join
-        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
-
-        # Supports the matcher composability features of RSpec 3+.
-        include Composable
-
-        # Makes the macro methods available to an `RSpec::Matchers.define` block.
-        extend Macros
-        extend Macros::Deprecated
-
-        # Exposes the value being matched against -- generally the object
-        # object wrapped by `expect`.
-        attr_reader :actual
-
-        # Exposes the exception raised during the matching by `match_unless_raises`.
-        # Could be useful to extract details for a failure message.
-        attr_reader :rescued_exception
-
-        # The block parameter used in the expectation
-        attr_reader :block_arg
-
-        # The name of the matcher.
-        attr_reader :name
-
-        # @api private
-        def initialize(name, declarations, matcher_execution_context, *expected, &block_arg)
-          @name     = name
-          @actual   = nil
-          @expected_as_array = expected
-          @matcher_execution_context = matcher_execution_context
-          @chained_method_clauses = []
-          @block_arg = block_arg
-
-          class << self
-            # See `Macros#define_user_override` above, for an explanation.
-            include(@user_method_defs = Module.new)
-            self
-          end.class_exec(*expected, &declarations)
-        end
-
-        # Provides the expected value. This will return an array if
-        # multiple arguments were passed to the matcher; otherwise it
-        # will return a single value.
-        # @see #expected_as_array
-        def expected
-          if expected_as_array.size == 1
-            expected_as_array[0]
-          else
-            expected_as_array
-          end
-        end
-
-        # Returns the expected value as an an array. This exists primarily
-        # to aid in upgrading from RSpec 2.x, since in RSpec 2, `expected`
-        # always returned an array.
-        # @see #expected
-        attr_reader :expected_as_array
-
-        # 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
-          # :nocov:
-          # 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
-          # :nocov:
-        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