cloudsmith-api 0.44.4 → 0.49.9

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.8.1/lib/rspec/mocks/any_instance/chain.rb

@@ -1,110 +0,0 @@
-module RSpec
-  module Mocks
-    # @private
-    module AnyInstance
-      # @private
-      class Chain
-        def initialize(recorder, *args, &block)
-          @recorder          = recorder
-          @expectation_args  = args
-          @expectation_block = block
-          @argument_list_matcher = ArgumentListMatcher::MATCH_ALL
-        end
-
-        # @private
-        #
-        # Provides convenience methods for recording customizations on message
-        # expectations.
-        module Customizations
-          # @macro [attach] record
-          #   @method $1(*args, &block)
-          #   Records the `$1` message for playback against an instance that
-          #   invokes a method stubbed or mocked using `any_instance`.
-          #
-          #   @see RSpec::Mocks::MessageExpectation#$1
-          #
-          def self.record(method_name)
-            define_method(method_name) do |*args, &block|
-              record(method_name, *args, &block)
-            end
-          end
-
-          record :and_return
-          record :and_raise
-          record :and_throw
-          record :and_yield
-          record :and_call_original
-          record :and_wrap_original
-          record :with
-          record :once
-          record :twice
-          record :thrice
-          record :exactly
-          record :times
-          record :never
-          record :at_least
-          record :at_most
-        end
-
-        include Customizations
-
-        # @private
-        def playback!(instance)
-          message_expectation = create_message_expectation_on(instance)
-          messages.inject(message_expectation) do |object, message|
-            object.__send__(*message.first, &message.last)
-          end
-        end
-
-        # @private
-        def constrained_to_any_of?(*constraints)
-          constraints.any? do |constraint|
-            messages.any? do |message|
-              message.first.first == constraint
-            end
-          end
-        end
-
-        # @private
-        def matches_args?(*args)
-          @argument_list_matcher.args_match?(*args)
-        end
-
-        # @private
-        def expectation_fulfilled!
-          @expectation_fulfilled = true
-        end
-
-        def never
-          AnyInstance.error_generator.raise_double_negation_error("expect_any_instance_of(MyClass)") if negated?
-          super
-        end
-
-        def with(*args, &block)
-          @argument_list_matcher = ArgumentListMatcher.new(*args)
-          super
-        end
-
-      private
-
-        def negated?
-          messages.any? { |(message, *_), _| message == :never }
-        end
-
-        def messages
-          @messages ||= []
-        end
-
-        def last_message
-          messages.last.first.first unless messages.empty?
-        end
-
-        def record(rspec_method_name, *args, &block)
-          verify_invocation_order(rspec_method_name, *args, &block)
-          messages << [args.unshift(rspec_method_name), block]
-          self
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.8.1/lib/rspec/mocks/any_instance/recorder.rb

@@ -1,289 +0,0 @@
-module RSpec
-  module Mocks
-    module AnyInstance
-      # Given a class `TheClass`, `TheClass.any_instance` returns a `Recorder`,
-      # which records stubs and message expectations for later playback on
-      # instances of `TheClass`.
-      #
-      # Further constraints are stored in instances of [Chain](Chain).
-      #
-      # @see AnyInstance
-      # @see Chain
-      class Recorder
-        # @private
-        attr_reader :message_chains, :stubs, :klass
-
-        def initialize(klass)
-          @message_chains = MessageChains.new
-          @stubs = Hash.new { |hash, key| hash[key] = [] }
-          @observed_methods = []
-          @played_methods = {}
-          @backed_up_method_owner = {}
-          @klass = klass
-          @expectation_set = false
-        end
-
-        # Initializes the recording a stub to be played back against any
-        # instance of this object that invokes the submitted method.
-        #
-        # @see Methods#stub
-        def stub(method_name, &block)
-          observe!(method_name)
-          message_chains.add(method_name, StubChain.new(self, method_name, &block))
-        end
-
-        # Initializes the recording a stub chain to be played back against any
-        # instance of this object that invokes the method matching the first
-        # argument.
-        #
-        # @see Methods#stub_chain
-        def stub_chain(*method_names_and_optional_return_values, &block)
-          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
-            observe!(method_name)
-            message_chains.add(method_name, StubChainChain.new(self, *args, &block))
-          end
-        end
-
-        # @private
-        def expect_chain(*method_names_and_optional_return_values, &block)
-          @expectation_set = true
-          normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
-            observe!(method_name)
-            message_chains.add(method_name, ExpectChainChain.new(self, *args, &block))
-          end
-        end
-
-        # Initializes the recording a message expectation to be played back
-        # against any instance of this object that invokes the submitted
-        # method.
-        #
-        # @see Methods#should_receive
-        def should_receive(method_name, &block)
-          @expectation_set = true
-          observe!(method_name)
-          message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
-        end
-
-        # The opposite of `should_receive`
-        #
-        # @see Methods#should_not_receive
-        def should_not_receive(method_name, &block)
-          should_receive(method_name, &block).never
-        end
-
-        # Removes any previously recorded stubs, stub_chains or message
-        # expectations that use `method_name`.
-        #
-        # @see Methods#unstub
-        def unstub(method_name)
-          unless @observed_methods.include?(method_name.to_sym)
-            AnyInstance.error_generator.raise_method_not_stubbed_error(method_name)
-          end
-          message_chains.remove_stub_chains_for!(method_name)
-          stubs[method_name].clear
-          stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
-        end
-
-        # @api private
-        #
-        # Used internally to verify that message expectations have been
-        # fulfilled.
-        def verify
-          return unless @expectation_set
-          return if message_chains.all_expectations_fulfilled?
-
-          AnyInstance.error_generator.raise_second_instance_received_message_error(message_chains.unfulfilled_expectations)
-        end
-
-        # @private
-        def stop_all_observation!
-          @observed_methods.each { |method_name| restore_method!(method_name) }
-        end
-
-        # @private
-        def playback!(instance, method_name)
-          RSpec::Mocks.space.ensure_registered(instance)
-          message_chains.playback!(instance, method_name)
-          @played_methods[method_name] = instance
-          received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
-        end
-
-        # @private
-        def instance_that_received(method_name)
-          @played_methods[method_name]
-        end
-
-        # @private
-        def build_alias_method_name(method_name)
-          "__#{method_name}_without_any_instance__"
-        end
-
-        # @private
-        def already_observing?(method_name)
-          @observed_methods.include?(method_name) || super_class_observing?(method_name)
-        end
-
-        # @private
-        def notify_received_message(_object, message, args, _blk)
-          has_expectation = false
-
-          message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
-            has_expectation = true
-            expectation.expectation_fulfilled!
-          end
-
-          return unless has_expectation
-
-          restore_method!(message)
-          mark_invoked!(message)
-        end
-
-      protected
-
-        def stop_observing!(method_name)
-          restore_method!(method_name)
-          @observed_methods.delete(method_name)
-          super_class_observers_for(method_name).each do |ancestor|
-            ::RSpec::Mocks.space.
-              any_instance_recorder_for(ancestor).stop_observing!(method_name)
-          end
-        end
-
-      private
-
-        def ancestor_is_an_observer?(method_name)
-          lambda do |ancestor|
-            unless ancestor == @klass
-              ::RSpec::Mocks.space.
-                any_instance_recorder_for(ancestor).already_observing?(method_name)
-            end
-          end
-        end
-
-        def super_class_observers_for(method_name)
-          @klass.ancestors.select(&ancestor_is_an_observer?(method_name))
-        end
-
-        def super_class_observing?(method_name)
-          @klass.ancestors.any?(&ancestor_is_an_observer?(method_name))
-        end
-
-        def normalize_chain(*args)
-          args.shift.to_s.split('.').map { |s| s.to_sym }.reverse.each { |a| args.unshift a }
-          yield args.first, args
-        end
-
-        def received_expected_message!(method_name)
-          message_chains.received_expected_message!(method_name)
-          restore_method!(method_name)
-          mark_invoked!(method_name)
-        end
-
-        def restore_method!(method_name)
-          if public_protected_or_private_method_defined?(build_alias_method_name(method_name))
-            restore_original_method!(method_name)
-          else
-            remove_dummy_method!(method_name)
-          end
-        end
-
-        def restore_original_method!(method_name)
-          return unless @klass.instance_method(method_name).owner == @klass
-
-          alias_method_name = build_alias_method_name(method_name)
-          @klass.class_exec(@backed_up_method_owner) do |backed_up_method_owner|
-            remove_method method_name
-
-            # A @klass can have methods implemented (see Method#owner) in @klass
-            # or inherited from a superclass. In ruby 2.2 and earlier, we can copy
-            # a method regardless of the 'owner' and restore it to @klass after
-            # because a call to 'super' from @klass's copied method would end up
-            # calling the original class's superclass's method.
-            #
-            # With the commit below, available starting in 2.3.0, ruby changed
-            # this behavior and a call to 'super' from the method copied to @klass
-            # will call @klass's superclass method, which is the original
-            # implementer of this method!  This leads to very strange errors
-            # if @klass's copied method calls 'super', since it would end up
-            # calling itself, the original method implemented in @klass's
-            # superclass.
-            #
-            # For ruby 2.3 and above, we need to only restore methods that
-            # @klass originally owned.
-            #
-            # https://github.com/ruby/ruby/commit/c8854d2ca4be9ee6946e6d17b0e17d9ef130ee81
-            if RUBY_VERSION < "2.3" || backed_up_method_owner[method_name.to_sym] == self
-              alias_method method_name, alias_method_name
-            end
-            remove_method alias_method_name
-          end
-        end
-
-        def remove_dummy_method!(method_name)
-          @klass.class_exec do
-            remove_method method_name
-          end
-        end
-
-        def backup_method!(method_name)
-          return unless public_protected_or_private_method_defined?(method_name)
-
-          alias_method_name = build_alias_method_name(method_name)
-          @backed_up_method_owner[method_name.to_sym] ||= @klass.instance_method(method_name).owner
-          @klass.class_exec do
-            alias_method alias_method_name, method_name
-          end
-        end
-
-        def public_protected_or_private_method_defined?(method_name)
-          MethodReference.method_defined_at_any_visibility?(@klass, method_name)
-        end
-
-        def observe!(method_name)
-          allow_no_prepended_module_definition_of(method_name)
-
-          if RSpec::Mocks.configuration.verify_partial_doubles? && !Mocks.configuration.temporarily_suppress_partial_double_verification
-            unless public_protected_or_private_method_defined?(method_name)
-              AnyInstance.error_generator.raise_does_not_implement_error(@klass, method_name)
-            end
-          end
-
-          stop_observing!(method_name) if already_observing?(method_name)
-          @observed_methods << method_name
-          backup_method!(method_name)
-          recorder = self
-          @klass.__send__(:define_method, method_name) do |*args, &blk|
-            recorder.playback!(self, method_name)
-            __send__(method_name, *args, &blk)
-          end
-        end
-
-        def mark_invoked!(method_name)
-          backup_method!(method_name)
-          recorder = self
-          @klass.__send__(:define_method, method_name) do |*_args, &_blk|
-            invoked_instance = recorder.instance_that_received(method_name)
-            inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
-            AnyInstance.error_generator.raise_message_already_received_by_other_instance_error(
-              method_name, inspect, invoked_instance
-            )
-          end
-        end
-
-        if Support::RubyFeatures.module_prepends_supported?
-          def allow_no_prepended_module_definition_of(method_name)
-            prepended_modules = RSpec::Mocks::Proxy.prepended_modules_of(@klass)
-            problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
-            return unless problem_mod
-
-            AnyInstance.error_generator.raise_not_supported_with_prepend_error(method_name, problem_mod)
-          end
-        else
-          def allow_no_prepended_module_definition_of(_method_name)
-            # nothing to do; prepends aren't supported on this version of ruby
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/rspec-mocks-3.8.1/lib/rspec/mocks/argument_matchers.rb

@@ -1,320 +0,0 @@
-# This cannot take advantage of our relative requires, since this file is a
-# dependency of `rspec/mocks/argument_list_matcher.rb`. See comment there for
-# details.
-require 'rspec/support/matcher_definition'
-
-module RSpec
-  module Mocks
-    # ArgumentMatchers are placeholders that you can include in message
-    # expectations to match arguments against a broader check than simple
-    # equality.
-    #
-    # With the exception of `any_args` and `no_args`, they all match against
-    # the arg in same position in the argument list.
-    #
-    # @see ArgumentListMatcher
-    module ArgumentMatchers
-      # Acts like an arg splat, matching any number of args at any point in an arg list.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(1, 2, any_args)
-      #
-      #   # matches any of these:
-      #   object.message(1, 2)
-      #   object.message(1, 2, 3)
-      #   object.message(1, 2, 3, 4)
-      def any_args
-        AnyArgsMatcher::INSTANCE
-      end
-
-      # Matches any argument at all.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(anything)
-      def anything
-        AnyArgMatcher::INSTANCE
-      end
-
-      # Matches no arguments.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(no_args)
-      def no_args
-        NoArgsMatcher::INSTANCE
-      end
-
-      # Matches if the actual argument responds to the specified messages.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(duck_type(:hello))
-      #   expect(object).to receive(:message).with(duck_type(:hello, :goodbye))
-      def duck_type(*args)
-        DuckTypeMatcher.new(*args)
-      end
-
-      # Matches a boolean value.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(boolean())
-      def boolean
-        BooleanMatcher::INSTANCE
-      end
-
-      # Matches a hash that includes the specified key(s) or key/value pairs.
-      # Ignores any additional keys.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(hash_including(:key => val))
-      #   expect(object).to receive(:message).with(hash_including(:key))
-      #   expect(object).to receive(:message).with(hash_including(:key, :key2 => val2))
-      def hash_including(*args)
-        HashIncludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
-      end
-
-      # Matches an array that includes the specified items at least once.
-      # Ignores duplicates and additional values
-      #
-      # @example
-      #   expect(object).to receive(:message).with(array_including(1,2,3))
-      #   expect(object).to receive(:message).with(array_including([1,2,3]))
-      def array_including(*args)
-        actually_an_array = Array === args.first && args.count == 1 ? args.first : args
-        ArrayIncludingMatcher.new(actually_an_array)
-      end
-
-      # Matches a hash that doesn't include the specified key(s) or key/value.
-      #
-      # @example
-      #   expect(object).to receive(:message).with(hash_excluding(:key => val))
-      #   expect(object).to receive(:message).with(hash_excluding(:key))
-      #   expect(object).to receive(:message).with(hash_excluding(:key, :key2 => :val2))
-      def hash_excluding(*args)
-        HashExcludingMatcher.new(ArgumentMatchers.anythingize_lonely_keys(*args))
-      end
-
-      alias_method :hash_not_including, :hash_excluding
-
-      # Matches if `arg.instance_of?(klass)`
-      #
-      # @example
-      #   expect(object).to receive(:message).with(instance_of(Thing))
-      def instance_of(klass)
-        InstanceOf.new(klass)
-      end
-
-      alias_method :an_instance_of, :instance_of
-
-      # Matches if `arg.kind_of?(klass)`
-      #
-      # @example
-      #   expect(object).to receive(:message).with(kind_of(Thing))
-      def kind_of(klass)
-        KindOf.new(klass)
-      end
-
-      alias_method :a_kind_of, :kind_of
-
-      # @private
-      def self.anythingize_lonely_keys(*args)
-        hash = Hash === args.last ? args.delete_at(-1) : {}
-        args.each { | arg | hash[arg] = AnyArgMatcher::INSTANCE }
-        hash
-      end
-
-      # Intended to be subclassed by stateless, immutable argument matchers.
-      # Provides a `<klass name>::INSTANCE` constant for accessing a global
-      # singleton instance of the matcher. There is no need to construct
-      # multiple instance since there is no state. It also facilities the
-      # special case logic we need for some of these matchers, by making it
-      # easy to do comparisons like: `[klass::INSTANCE] == args` rather than
-      # `args.count == 1 && klass === args.first`.
-      #
-      # @private
-      class SingletonMatcher
-        private_class_method :new
-
-        def self.inherited(subklass)
-          subklass.const_set(:INSTANCE, subklass.send(:new))
-        end
-      end
-
-      # @private
-      class AnyArgsMatcher < SingletonMatcher
-        def description
-          "*(any args)"
-        end
-      end
-
-      # @private
-      class AnyArgMatcher < SingletonMatcher
-        def ===(_other)
-          true
-        end
-
-        def description
-          "anything"
-        end
-      end
-
-      # @private
-      class NoArgsMatcher < SingletonMatcher
-        def description
-          "no args"
-        end
-      end
-
-      # @private
-      class BooleanMatcher < SingletonMatcher
-        def ===(value)
-          true == value || false == value
-        end
-
-        def description
-          "boolean"
-        end
-      end
-
-      # @private
-      class BaseHashMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ===(predicate, actual)
-          @expected.__send__(predicate) do |k, v|
-            actual.key?(k) && Support::FuzzyMatcher.values_match?(v, actual[k])
-          end
-        rescue NoMethodError
-          false
-        end
-
-        def description(name)
-          "#{name}(#{formatted_expected_hash.inspect.sub(/^\{/, "").sub(/\}$/, "")})"
-        end
-
-      private
-
-        def formatted_expected_hash
-          Hash[
-            @expected.map do |k, v|
-              k = RSpec::Support.rspec_description_for_object(k)
-              v = RSpec::Support.rspec_description_for_object(v)
-
-              [k, v]
-            end
-          ]
-        end
-      end
-
-      # @private
-      class HashIncludingMatcher < BaseHashMatcher
-        def ===(actual)
-          super(:all?, actual)
-        end
-
-        def description
-          super("hash_including")
-        end
-      end
-
-      # @private
-      class HashExcludingMatcher < BaseHashMatcher
-        def ===(actual)
-          super(:none?, actual)
-        end
-
-        def description
-          super("hash_not_including")
-        end
-      end
-
-      # @private
-      class ArrayIncludingMatcher
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def ===(actual)
-          actual = actual.uniq
-          @expected.uniq.all? do |expected_element|
-            actual.any? do |actual_element|
-              RSpec::Support::FuzzyMatcher.values_match?(expected_element, actual_element)
-            end
-          end
-        end
-
-        def description
-          "array_including(#{formatted_expected_values})"
-        end
-
-      private
-
-        def formatted_expected_values
-          @expected.map do |x|
-            RSpec::Support.rspec_description_for_object(x)
-          end.join(", ")
-        end
-      end
-
-      # @private
-      class DuckTypeMatcher
-        def initialize(*methods_to_respond_to)
-          @methods_to_respond_to = methods_to_respond_to
-        end
-
-        def ===(value)
-          @methods_to_respond_to.all? { |message| value.respond_to?(message) }
-        end
-
-        def description
-          "duck_type(#{@methods_to_respond_to.map(&:inspect).join(', ')})"
-        end
-      end
-
-      # @private
-      class InstanceOf
-        def initialize(klass)
-          @klass = klass
-        end
-
-        def ===(actual)
-          actual.instance_of?(@klass)
-        end
-
-        def description
-          "an_instance_of(#{@klass.name})"
-        end
-      end
-
-      # @private
-      class KindOf
-        def initialize(klass)
-          @klass = klass
-        end
-
-        def ===(actual)
-          actual.kind_of?(@klass)
-        end
-
-        def description
-          "kind of #{@klass.name}"
-        end
-      end
-
-      matcher_namespace = name + '::'
-      ::RSpec::Support.register_matcher_definition do |object|
-        # This is the best we have for now. We should tag all of our matchers
-        # with a module or something so we can test for it directly.
-        #
-        # (Note Module#parent in ActiveSupport is defined in a similar way.)
-        begin
-          object.class.name.include?(matcher_namespace)
-        rescue NoMethodError
-          # Some objects, like BasicObject, don't implemented standard
-          # reflection methods.
-          false
-        end
-      end
-    end
-  end
-end