svix 0.53.1 → 0.53.2

data/vendor/bundle/ruby/2.7.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/exist.rb

@@ -1,90 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `exist`.
-      # Not intended to be instantiated directly.
-      class Exist < BaseMatcher
-        def initialize(*expected)
-          @expected = expected
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          @actual = actual
-          @test = ExistenceTest.new @actual, @expected
-          @test.valid_test? && @test.actual_exists?
-        end
-
-        # @api private
-        # @return [Boolean]
-        def does_not_match?(actual)
-          @actual = actual
-          @test = ExistenceTest.new @actual, @expected
-          @test.valid_test? && !@test.actual_exists?
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to exist#{@test.validity_message}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{actual_formatted} not to exist#{@test.validity_message}"
-        end
-
-        # @api private
-        # Simple class for memoizing actual/expected for this matcher
-        # and examining the match
-        class ExistenceTest < Struct.new(:actual, :expected)
-          # @api private
-          # @return [Boolean]
-          def valid_test?
-            uniq_truthy_values.size == 1
-          end
-
-          # @api private
-          # @return [Boolean]
-          def actual_exists?
-            existence_values.first
-          end
-
-          # @api private
-          # @return [String]
-          def validity_message
-            case uniq_truthy_values.size
-            when 0
-              " but it does not respond to either `exist?` or `exists?`"
-            when 2
-              " but `exist?` and `exists?` returned different values:\n\n"\
-              " exist?: #{existence_values.first}\n"\
-              "exists?: #{existence_values.last}"
-            end
-          end
-
-        private
-
-          def uniq_truthy_values
-            @uniq_truthy_values ||= existence_values.map { |v| !!v }.uniq
-          end
-
-          def existence_values
-            @existence_values ||= predicates.map { |p| actual.__send__(p, *expected) }
-          end
-
-          def predicates
-            @predicates ||= [:exist?, :exists?].select { |p| actual.respond_to?(p) && !deprecated(p, actual) }
-          end
-
-          def deprecated(predicate, actual)
-            predicate == :exists? && File == actual
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/has.rb

@@ -1,167 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for dynamic predicate matchers.
-      # Not intended to be inherited directly.
-      class DynamicPredicate < BaseMatcher
-        include BeHelpers
-
-        def initialize(method_name, *args, &block)
-          @method_name, @args, @block = method_name, args, block
-        end
-        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
-
-        # @private
-        def matches?(actual, &block)
-          @actual = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?
-        end
-
-        # @private
-        def does_not_match?(actual, &block)
-          @actual = actual
-          @block ||= block
-          predicate_accessible? && predicate_matches?(false)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          failure_message_expecting(true)
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          failure_message_expecting(false)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          "#{method_description}#{args_to_sentence}"
-        end
-
-      private
-
-        def predicate_accessible?
-          @actual.respond_to? predicate
-        end
-
-        # support 1.8.7, evaluate once at load time for performance
-        if String === methods.first
-          # :nocov:
-          def private_predicate?
-            @actual.private_methods.include? predicate.to_s
-          end
-          # :nocov:
-        else
-          def private_predicate?
-            @actual.private_methods.include? predicate
-          end
-        end
-
-        def predicate_result
-          @predicate_result = actual.__send__(predicate_method_name, *@args, &@block)
-        end
-
-        def predicate_method_name
-          predicate
-        end
-
-        def predicate_matches?(value=true)
-          if RSpec::Expectations.configuration.strict_predicate_matchers?
-            value == predicate_result
-          else
-            value == !!predicate_result
-          end
-        end
-
-        def root
-          # On 1.9, there appears to be a bug where String#match can return `false`
-          # rather than the match data object. Changing to Regex#match appears to
-          # work around this bug. For an example of this bug, see:
-          # https://travis-ci.org/rspec/rspec-expectations/jobs/27549635
-          self.class::REGEX.match(@method_name.to_s).captures.first
-        end
-
-        def method_description
-          EnglishPhrasing.split_words(@method_name)
-        end
-
-        def failure_message_expecting(value)
-          validity_message ||
-            "expected `#{actual_formatted}.#{predicate}#{args_to_s}` to #{expectation_of value}, got #{description_of @predicate_result}"
-        end
-
-        def expectation_of(value)
-          if RSpec::Expectations.configuration.strict_predicate_matchers?
-            "return #{value}"
-          elsif value
-            "be truthy"
-          else
-            "be falsey"
-          end
-        end
-
-        def validity_message
-          return nil if predicate_accessible?
-
-          "expected #{actual_formatted} to respond to `#{predicate}`#{failure_to_respond_explanation}"
-        end
-
-        def failure_to_respond_explanation
-          if private_predicate?
-            " but `#{predicate}` is a private method"
-          end
-        end
-      end
-
-      # @api private
-      # Provides the implementation for `has_<predicate>`.
-      # Not intended to be instantiated directly.
-      class Has < DynamicPredicate
-        # :nodoc:
-        REGEX = Matchers::HAS_REGEX
-      private
-        def predicate
-          @predicate ||= :"has_#{root}?"
-        end
-      end
-
-      # @api private
-      # Provides the implementation of `be_<predicate>`.
-      # Not intended to be instantiated directly.
-      class BePredicate < DynamicPredicate
-        # :nodoc:
-        REGEX = Matchers::BE_PREDICATE_REGEX
-      private
-        def predicate
-          @predicate ||= :"#{root}?"
-        end
-
-        def predicate_method_name
-          actual.respond_to?(predicate) ? predicate : present_tense_predicate
-        end
-
-        def failure_to_respond_explanation
-          super || if predicate == :true?
-                     " or perhaps you meant `be true` or `be_truthy`"
-                   elsif predicate == :false?
-                     " or perhaps you meant `be false` or `be_falsey`"
-                   end
-        end
-
-        def predicate_accessible?
-          super || actual.respond_to?(present_tense_predicate)
-        end
-
-        def present_tense_predicate
-          :"#{root}s?"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/have_attributes.rb

@@ -1,114 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `have_attributes`.
-      # Not intended to be instantiated directly.
-      class HaveAttributes < BaseMatcher
-        # @private
-        attr_reader :respond_to_failed
-
-        def initialize(expected)
-          @expected = expected
-          @values = {}
-          @respond_to_failed = false
-          @negated = false
-        end
-
-        # @private
-        def actual
-          @values
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          @actual = actual
-          @negated = false
-          return false unless respond_to_attributes?
-          perform_match(:all?)
-        end
-
-        # @api private
-        # @return [Boolean]
-        def does_not_match?(actual)
-          @actual = actual
-          @negated = true
-          return false unless respond_to_attributes?
-          perform_match(:none?)
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          described_items = surface_descriptions_in(expected)
-          improve_hash_formatting "have attributes #{RSpec::Support::ObjectFormatter.format(described_items)}"
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          !@respond_to_failed && !@negated
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          respond_to_failure_message_or do
-            "expected #{actual_formatted} to #{description} but had attributes #{ formatted_values }"
-          end
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          respond_to_failure_message_or { "expected #{actual_formatted} not to #{description}" }
-        end
-
-      private
-
-        def cache_all_values
-          @values = {}
-          expected.each do |attribute_key, _attribute_value|
-            actual_value = @actual.__send__(attribute_key)
-            @values[attribute_key] = actual_value
-          end
-        end
-
-        def perform_match(predicate)
-          cache_all_values
-          expected.__send__(predicate) do |attribute_key, attribute_value|
-            actual_has_attribute?(attribute_key, attribute_value)
-          end
-        end
-
-        def actual_has_attribute?(attribute_key, attribute_value)
-          values_match?(attribute_value, @values.fetch(attribute_key))
-        end
-
-        def respond_to_attributes?
-          matches = respond_to_matcher.matches?(@actual)
-          @respond_to_failed = !matches
-          matches
-        end
-
-        def respond_to_matcher
-          @respond_to_matcher ||= RespondTo.new(*expected.keys).with(0).arguments.tap { |m| m.ignoring_method_signature_failure! }
-        end
-
-        def respond_to_failure_message_or
-          if respond_to_failed
-            respond_to_matcher.failure_message
-          else
-            improve_hash_formatting(yield)
-          end
-        end
-
-        def formatted_values
-          values = RSpec::Support::ObjectFormatter.format(@values)
-          improve_hash_formatting(values)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/include.rb

@@ -1,206 +0,0 @@
-require 'rspec/matchers/built_in/count_expectation'
-
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `include`.
-      # Not intended to be instantiated directly.
-      class Include < BaseMatcher # rubocop:disable Metrics/ClassLength
-        include CountExpectation
-        # @private
-        attr_reader :expecteds
-
-        # @api private
-        def initialize(*expecteds)
-          @expecteds = expecteds
-        end
-
-        # @api private
-        # @return [Boolean]
-        def matches?(actual)
-          check_actual?(actual) &&
-            if check_expected_count?
-              expected_count_matches?(count_inclusions)
-            else
-              perform_match { |v| v }
-            end
-        end
-
-        # @api private
-        # @return [Boolean]
-        def does_not_match?(actual)
-          check_actual?(actual) &&
-            if check_expected_count?
-              !expected_count_matches?(count_inclusions)
-            else
-              perform_match { |v| !v }
-            end
-        end
-
-        # @api private
-        # @return [String]
-        def description
-          improve_hash_formatting("include#{readable_list_of(expecteds)}#{count_expectation_description}")
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          format_failure_message("to") { super }
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          format_failure_message("not to") { super }
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          !diff_would_wrongly_highlight_matched_item?
-        end
-
-        # @api private
-        # @return [Array, Hash]
-        def expected
-          if expecteds.one? && Hash === expecteds.first
-            expecteds.first
-          else
-            expecteds
-          end
-        end
-
-      private
-
-        def check_actual?(actual)
-          actual = actual.to_hash if convert_to_hash?(actual)
-          @actual = actual
-          @actual.respond_to?(:include?)
-        end
-
-        def check_expected_count?
-          case
-          when !has_expected_count?
-            return false
-          when expecteds.size != 1
-            raise NotImplementedError, 'Count constraint supported only when testing for a single value being included'
-          when actual.is_a?(Hash)
-            raise NotImplementedError, 'Count constraint on hash keys not implemented'
-          end
-          true
-        end
-
-        def format_failure_message(preposition)
-          msg = if actual.respond_to?(:include?)
-                  "expected #{description_of @actual} #{preposition}" \
-                  " include#{readable_list_of @divergent_items}" \
-                  "#{count_failure_reason('it is included') if has_expected_count?}"
-                else
-                  "#{yield}, but it does not respond to `include?`"
-                end
-          improve_hash_formatting(msg)
-        end
-
-        def readable_list_of(items)
-          described_items = surface_descriptions_in(items)
-          if described_items.all? { |item| item.is_a?(Hash) }
-            " #{described_items.inject(:merge).inspect}"
-          else
-            EnglishPhrasing.list(described_items)
-          end
-        end
-
-        def perform_match(&block)
-          @divergent_items = excluded_from_actual(&block)
-          @divergent_items.empty?
-        end
-
-        def excluded_from_actual
-          return [] unless @actual.respond_to?(:include?)
-
-          expecteds.inject([]) do |memo, expected_item|
-            if comparing_hash_to_a_subset?(expected_item)
-              expected_item.each do |(key, value)|
-                memo << { key => value } unless yield actual_hash_includes?(key, value)
-              end
-            elsif comparing_hash_keys?(expected_item)
-              memo << expected_item unless yield actual_hash_has_key?(expected_item)
-            else
-              memo << expected_item unless yield actual_collection_includes?(expected_item)
-            end
-            memo
-          end
-        end
-
-        def comparing_hash_to_a_subset?(expected_item)
-          actual.is_a?(Hash) && expected_item.is_a?(Hash)
-        end
-
-        def actual_hash_includes?(expected_key, expected_value)
-          actual_value =
-            actual.fetch(expected_key) do
-              actual.find(Proc.new { return false }) { |actual_key, _| values_match?(expected_key, actual_key) }[1]
-            end
-          values_match?(expected_value, actual_value)
-        end
-
-        def comparing_hash_keys?(expected_item)
-          actual.is_a?(Hash) && !expected_item.is_a?(Hash)
-        end
-
-        def actual_hash_has_key?(expected_key)
-          # We check `key?` first for perf:
-          # `key?` is O(1), but `any?` is O(N).
-          actual.key?(expected_key) ||
-          actual.keys.any? { |key| values_match?(expected_key, key) }
-        end
-
-        def actual_collection_includes?(expected_item)
-          return true if actual.include?(expected_item)
-
-          # String lacks an `any?` method...
-          return false unless actual.respond_to?(:any?)
-
-          actual.any? { |value| values_match?(expected_item, value) }
-        end
-
-        if RUBY_VERSION < '1.9'
-          def count_enumerable(expected_item)
-            actual.select { |value| values_match?(expected_item, value) }.size
-          end
-        else
-          def count_enumerable(expected_item)
-            actual.count { |value| values_match?(expected_item, value) }
-          end
-        end
-
-        def count_inclusions
-          @divergent_items = expected
-          case actual
-          when String
-            actual.scan(expected.first).length
-          when Enumerable
-            count_enumerable(expected.first)
-          else
-            raise NotImplementedError, 'Count constraints are implemented for Enumerable and String values only'
-          end
-        end
-
-        def diff_would_wrongly_highlight_matched_item?
-          return false unless actual.is_a?(String) && expected.is_a?(Array)
-
-          lines = actual.split("\n")
-          expected.any? do |str|
-            actual.include?(str) && lines.none? { |line| line == str }
-          end
-        end
-
-        def convert_to_hash?(obj)
-          !obj.respond_to?(:include?) && obj.respond_to?(:to_hash)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/rspec-expectations-3.10.1/lib/rspec/matchers/built_in/match.rb

@@ -1,106 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `match`.
-      # Not intended to be instantiated directly.
-      class Match < BaseMatcher
-        def initialize(expected)
-          super(expected)
-
-          @expected_captures = nil
-        end
-        # @api private
-        # @return [String]
-        def description
-          if @expected_captures && @expected.match(actual)
-            "match #{surface_descriptions_in(expected).inspect} with captures #{surface_descriptions_in(@expected_captures).inspect}"
-          else
-            "match #{surface_descriptions_in(expected).inspect}"
-          end
-        end
-
-        # @api private
-        # @return [Boolean]
-        def diffable?
-          true
-        end
-
-        # Used to specify the captures we match against
-        # @return [self]
-        def with_captures(*captures)
-          @expected_captures = captures
-          self
-        end
-
-      private
-
-        def match(expected, actual)
-          return match_captures(expected, actual) if @expected_captures
-          return true if values_match?(expected, actual)
-          return false unless can_safely_call_match?(expected, actual)
-          actual.match(expected)
-        end
-
-        def can_safely_call_match?(expected, actual)
-          return false unless actual.respond_to?(:match)
-
-          !(RSpec::Matchers.is_a_matcher?(expected) &&
-            (String === actual || Regexp === actual))
-        end
-
-        def match_captures(expected, actual)
-          match = actual.match(expected)
-          if match
-            match = ReliableMatchData.new(match)
-            if match.names.empty?
-              values_match?(@expected_captures, match.captures)
-            else
-              expected_matcher = @expected_captures.last
-              values_match?(expected_matcher, Hash[match.names.zip(match.captures)]) ||
-                values_match?(expected_matcher, Hash[match.names.map(&:to_sym).zip(match.captures)]) ||
-                values_match?(@expected_captures, match.captures)
-            end
-          else
-            false
-          end
-        end
-      end
-
-      # @api private
-      # Used to wrap match data and make it reliable for 1.8.7
-      class ReliableMatchData
-        def initialize(match_data)
-          @match_data = match_data
-        end
-
-        if RUBY_VERSION == "1.8.7"
-          # @api private
-          # Returns match data names for named captures
-          # @return Array
-          def names
-            []
-          end
-        else
-          # @api private
-          # Returns match data names for named captures
-          # @return Array
-          def names
-            match_data.names
-          end
-        end
-
-        # @api private
-        # returns an array of captures from the match data
-        # @return Array
-        def captures
-          match_data.captures
-        end
-
-      protected
-
-        attr_reader :match_data
-      end
-    end
-  end
-end