cloudsmith-api 0.57.1 → 1.30.0

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.11.0/lib/rspec/expectations/version.rb

@@ -0,0 +1,8 @@
+module RSpec
+  module Expectations
+    # @private
+    module Version
+      STRING = '3.11.0'
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.11.0/lib/rspec/matchers/built_in/base_matcher.rb

@@ -0,0 +1,198 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      #
+      # Used _internally_ as a base class for matchers that ship with
+      # rspec-expectations and rspec-rails.
+      #
+      # ### Warning:
+      #
+      # This class is for internal use, and subject to change without notice.
+      # We strongly recommend that you do not base your custom matchers on this
+      # class. If/when this changes, we will announce it and remove this warning.
+      class BaseMatcher
+        include RSpec::Matchers::Composable
+
+        # @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
+
+        # @private
+        attr_writer :matcher_name
+
+        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
+
+        # @api private
+        # Used to wrap a block of code that will indicate failure by
+        # raising one of the named exceptions.
+        #
+        # This is used by rspec-rails for some of its matchers that
+        # wrap rails' assertions.
+        def match_unless_raises(*exceptions)
+          exceptions.unshift Exception if exceptions.empty?
+          begin
+            yield
+            true
+          rescue *exceptions => @rescued_exception
+            false
+          end
+        end
+
+        # @api private
+        # Generates a description using {EnglishPhrasing}.
+        # @return [String]
+        def description
+          desc = EnglishPhrasing.split_words(self.class.matcher_name)
+          desc << EnglishPhrasing.list(@expected) if defined?(@expected)
+          desc
+        end
+
+        # @api private
+        # Matchers are not diffable by default. Override this to make your
+        # subclass diffable.
+        def diffable?
+          false
+        end
+
+        # @api private
+        # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
+        # rather than block matchers (i.e. meant to work with `expect { }`), so
+        # this defaults to false. Block matchers must override this to return true.
+        def supports_block_expectations?
+          false
+        end
+
+        # @private
+        def supports_value_expectations?
+          true
+        end
+
+        # @api private
+        def expects_call_stack_jump?
+          false
+        end
+
+        # @private
+        def expected_formatted
+          RSpec::Support::ObjectFormatter.format(@expected)
+        end
+
+        # @private
+        def actual_formatted
+          RSpec::Support::ObjectFormatter.format(@actual)
+        end
+
+        # @private
+        def self.matcher_name
+          @matcher_name ||= underscore(name.split('::').last)
+        end
+
+        # @private
+        def matcher_name
+          if defined?(@matcher_name)
+            @matcher_name
+          else
+            self.class.matcher_name
+          end
+        end
+
+        # @private
+        # Borrowed from ActiveSupport.
+        def self.underscore(camel_cased_word)
+          word = camel_cased_word.to_s.dup
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.tr!('-', '_')
+          word.downcase!
+          word
+        end
+        private_class_method :underscore
+
+      private
+
+        def assert_ivars(*expected_ivars)
+          return unless (expected_ivars - present_ivars).any?
+          ivar_list = EnglishPhrasing.list(expected_ivars)
+          raise "#{self.class.name} needs to supply#{ivar_list}"
+        end
+
+        if RUBY_VERSION.to_f < 1.9
+          # :nocov:
+          def present_ivars
+            instance_variables.map(&:to_sym)
+          end
+          # :nocov:
+        else
+          alias present_ivars instance_variables
+        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}".dup
+          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}".dup
+          end
+
+          # @private
+          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
+        end
+
+        include DefaultFailureMessages
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rspec-expectations-3.11.0/lib/rspec/matchers/built_in/change.rb

@@ -0,0 +1,450 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      # Provides the implementation for `change`.
+      # Not intended to be instantiated directly.
+      class Change < BaseMatcher
+        # @api public
+        # Specifies the delta of the expected change.
+        def by(expected_delta)
+          ChangeRelatively.new(change_details, expected_delta, :by) do |actual_delta|
+            values_match?(expected_delta, actual_delta)
+          end
+        end
+
+        # @api public
+        # Specifies a minimum delta of the expected change.
+        def by_at_least(minimum)
+          ChangeRelatively.new(change_details, minimum, :by_at_least) do |actual_delta|
+            actual_delta >= minimum
+          end
+        end
+
+        # @api public
+        # Specifies a maximum delta of the expected change.
+        def by_at_most(maximum)
+          ChangeRelatively.new(change_details, maximum, :by_at_most) do |actual_delta|
+            actual_delta <= maximum
+          end
+        end
+
+        # @api public
+        # Specifies the new value you expect.
+        def to(value)
+          ChangeToValue.new(change_details, value)
+        end
+
+        # @api public
+        # Specifies the original value.
+        def from(value)
+          ChangeFromValue.new(change_details, value)
+        end
+
+        # @private
+        def matches?(event_proc)
+          raise_block_syntax_error if block_given?
+          perform_change(event_proc) && change_details.changed?
+        end
+
+        def does_not_match?(event_proc)
+          raise_block_syntax_error if block_given?
+          perform_change(event_proc) && !change_details.changed?
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message
+          "expected #{change_details.value_representation} to have changed, " \
+          "but #{positive_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def failure_message_when_negated
+          "expected #{change_details.value_representation} not to have changed, " \
+          "but #{negative_failure_reason}"
+        end
+
+        # @api private
+        # @return [String]
+        def description
+          "change #{change_details.value_representation}"
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
+      private
+
+        def initialize(receiver=nil, message=nil, &block)
+          @receiver = receiver
+          @message = message
+          @block = block
+        end
+
+        def change_details
+          @change_details ||= ChangeDetails.new(matcher_name, @receiver, @message, &@block)
+        end
+
+        def perform_change(event_proc)
+          @event_proc = event_proc
+          change_details.perform_change(event_proc) do |actual_before|
+            # pre-compute values derived from the `before` value before the
+            # mutation is applied, in case the specified mutation is mutation
+            # of a single object (rather than a changing what object a method
+            # returns). We need to cache these values before the `before` value
+            # they are based on potentially gets mutated.
+            @actual_before_description = description_of(actual_before)
+          end
+        end
+
+        def raise_block_syntax_error
+          raise SyntaxError, "Block not received by the `change` matcher. " \
+          "Perhaps you want to use `{ ... }` instead of do/end?"
+        end
+
+        def positive_failure_reason
+          return "was not given a block" unless Proc === @event_proc
+          "is still #{@actual_before_description}"
+        end
+
+        def negative_failure_reason
+          return "was not given a block" unless Proc === @event_proc
+          "did change from #{@actual_before_description} " \
+          "to #{description_of change_details.actual_after}"
+        end
+      end
+
+      # Used to specify a relative change.
+      # @api private
+      class ChangeRelatively < BaseMatcher
+        def initialize(change_details, expected_delta, relativity, &comparer)
+          @change_details = change_details
+          @expected_delta = expected_delta
+          @relativity     = relativity
+          @comparer       = comparer
+        end
+
+        # @private
+        def failure_message
+          "expected #{@change_details.value_representation} to have changed " \
+          "#{@relativity.to_s.tr('_', ' ')} " \
+          "#{description_of @expected_delta}, but #{failure_reason}"
+        end
+
+        # @private
+        def matches?(event_proc)
+          @event_proc = event_proc
+          @change_details.perform_change(event_proc) && @comparer.call(@change_details.actual_delta)
+        end
+
+        # @private
+        def does_not_match?(_event_proc)
+          raise NotImplementedError, "`expect { }.not_to change " \
+            "{ }.#{@relativity}()` is not supported"
+        end
+
+        # @private
+        def description
+          "change #{@change_details.value_representation} " \
+          "#{@relativity.to_s.tr('_', ' ')} #{description_of @expected_delta}"
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
+      private
+
+        def failure_reason
+          return "was not given a block" unless Proc === @event_proc
+          "was changed by #{description_of @change_details.actual_delta}"
+        end
+      end
+
+      # @api private
+      # Base class for specifying a change from and/or to specific values.
+      class SpecificValuesChange < BaseMatcher
+        # @private
+        MATCH_ANYTHING = ::Object.ancestors.last
+
+        def initialize(change_details, from, to)
+          @change_details  = change_details
+          @expected_before = from
+          @expected_after  = to
+        end
+
+        # @private
+        def matches?(event_proc)
+          perform_change(event_proc) && @change_details.changed? && @matches_before && matches_after?
+        end
+
+        # @private
+        def description
+          "change #{@change_details.value_representation} #{change_description}"
+        end
+
+        # @private
+        def failure_message
+          return not_given_a_block_failure unless Proc === @event_proc
+          return before_value_failure      unless @matches_before
+          return did_not_change_failure    unless @change_details.changed?
+          after_value_failure
+        end
+
+        # @private
+        def supports_block_expectations?
+          true
+        end
+
+        # @private
+        def supports_value_expectations?
+          false
+        end
+
+      private
+
+        def perform_change(event_proc)
+          @event_proc = event_proc
+          @change_details.perform_change(event_proc) do |actual_before|
+            # pre-compute values derived from the `before` value before the
+            # mutation is applied, in case the specified mutation is mutation
+            # of a single object (rather than a changing what object a method
+            # returns). We need to cache these values before the `before` value
+            # they are based on potentially gets mutated.
+            @matches_before = values_match?(@expected_before, actual_before)
+            @actual_before_description = description_of(actual_before)
+          end
+        end
+
+        def matches_after?
+          values_match?(@expected_after, @change_details.actual_after)
+        end
+
+        def before_value_failure
+          "expected #{@change_details.value_representation} " \
+          "to have initially been #{description_of @expected_before}, " \
+          "but was #{@actual_before_description}"
+        end
+
+        def after_value_failure
+          "expected #{@change_details.value_representation} " \
+          "to have changed to #{description_of @expected_after}, " \
+          "but is now #{description_of @change_details.actual_after}"
+        end
+
+        def did_not_change_failure
+          "expected #{@change_details.value_representation} " \
+          "to have changed #{change_description}, but did not change"
+        end
+
+        def did_change_failure
+          "expected #{@change_details.value_representation} not to have changed, but " \
+          "did change from #{@actual_before_description} " \
+          "to #{description_of @change_details.actual_after}"
+        end
+
+        def not_given_a_block_failure
+          "expected #{@change_details.value_representation} to have changed " \
+          "#{change_description}, but was not given a block"
+        end
+      end
+
+      # @api private
+      # Used to specify a change from a specific value
+      # (and, optionally, to a specific value).
+      class ChangeFromValue < SpecificValuesChange
+        def initialize(change_details, expected_before)
+          @description_suffix = nil
+          super(change_details, expected_before, MATCH_ANYTHING)
+        end
+
+        # @api public
+        # Specifies the new value you expect.
+        def to(value)
+          @expected_after     = value
+          @description_suffix = " to #{description_of value}"
+          self
+        end
+
+        # @private
+        def does_not_match?(event_proc)
+          if @description_suffix
+            raise NotImplementedError, "`expect { }.not_to change { }.to()` " \
+              "is not supported"
+          end
+
+          perform_change(event_proc) && !@change_details.changed? && @matches_before
+        end
+
+        # @private
+        def failure_message_when_negated
+          return not_given_a_block_failure unless Proc === @event_proc
+          return before_value_failure unless @matches_before
+          did_change_failure
+        end
+
+      private
+
+        def change_description
+          "from #{description_of @expected_before}#{@description_suffix}"
+        end
+      end
+
+      # @api private
+      # Used to specify a change to a specific value
+      # (and, optionally, from a specific value).
+      class ChangeToValue < SpecificValuesChange
+        def initialize(change_details, expected_after)
+          @description_suffix = nil
+          super(change_details, MATCH_ANYTHING, expected_after)
+        end
+
+        # @api public
+        # Specifies the original value.
+        def from(value)
+          @expected_before    = value
+          @description_suffix = " from #{description_of value}"
+          self
+        end
+
+        # @private
+        def does_not_match?(_event_proc)
+          raise NotImplementedError, "`expect { }.not_to change { }.to()` " \
+            "is not supported"
+        end
+
+      private
+
+        def change_description
+          "to #{description_of @expected_after}#{@description_suffix}"
+        end
+      end
+
+      # @private
+      # Encapsulates the details of the before/after values.
+      #
+      # Note that this class exposes the `actual_after` value, to allow the
+      # matchers above to derive failure messages, etc from the value on demand
+      # as needed, but it intentionally does _not_ expose the `actual_before`
+      # value. Some usages of the `change` matcher mutate a specific object
+      # returned by the value proc, which means that failure message snippets,
+      # etc, which are derived from the `before` value may not be accurate if
+      # they are lazily computed as needed. We must pre-compute them before
+      # applying the change in the `expect` block. To ensure that all `change`
+      # matchers do that properly, we do not expose the `actual_before` value.
+      # Instead, matchers must pass a block to `perform_change`, which yields
+      # the `actual_before` value before applying the change.
+      class ChangeDetails
+        attr_reader :actual_after
+
+        UNDEFINED = Module.new.freeze
+
+        def initialize(matcher_name, receiver=nil, message=nil, &block)
+          if receiver && !message
+            raise(
+              ArgumentError,
+              "`change` requires either an object and message " \
+              "(`change(obj, :msg)`) or a block (`change { }`). " \
+              "You passed an object but no message."
+            )
+          end
+
+          @matcher_name = matcher_name
+          @receiver = receiver
+          @message = message
+          @value_proc = block
+          # TODO: temporary measure to mute warning of access to an initialized
+          # instance variable when a deprecated implicit block expectation
+          # syntax is used. This may be removed once `fail` is used, and the
+          # matcher never issues this warning.
+          @actual_after = UNDEFINED
+        end
+
+        def value_representation
+          @value_representation ||=
+            if @message
+              "`#{message_notation(@receiver, @message)}`"
+            elsif (value_block_snippet = extract_value_block_snippet)
+              "`#{value_block_snippet}`"
+            else
+              'result'
+            end
+        end
+
+        def perform_change(event_proc)
+          @actual_before = evaluate_value_proc
+          @before_hash = @actual_before.hash
+          yield @actual_before if block_given?
+
+          return false unless Proc === event_proc
+          event_proc.call
+
+          @actual_after = evaluate_value_proc
+          @actual_hash = @actual_after.hash
+          true
+        end
+
+        def changed?
+          # Consider it changed if either:
+          #
+          # - The before/after values are unequal
+          # - The before/after values have different hash values
+          #
+          # The latter case specifically handles the case when the value proc
+          # returns the exact same object, but it has been mutated.
+          #
+          # Note that it is not sufficient to only check the hashes; it is
+          # possible for two values to be unequal (and of different classes)
+          # but to return the same hash value. Also, some objects may change
+          # their hash after being compared with `==`/`!=`.
+          @actual_before != @actual_after || @before_hash != @actual_hash
+        end
+
+        def actual_delta
+          @actual_after - @actual_before
+        end
+
+      private
+
+        def evaluate_value_proc
+          @value_proc ? @value_proc.call : @receiver.__send__(@message)
+        end
+
+        def message_notation(receiver, message)
+          case receiver
+          when Module
+            "#{receiver}.#{message}"
+          else
+            "#{Support.class_of(receiver)}##{message}"
+          end
+        end
+
+        if RSpec::Support::RubyFeatures.ripper_supported?
+          def extract_value_block_snippet
+            return nil unless @value_proc
+            Expectations::BlockSnippetExtractor.try_extracting_single_line_body_of(@value_proc, @matcher_name)
+          end
+        else
+          def extract_value_block_snippet
+            nil
+          end
+        end
+      end
+    end
+  end
+end