ory-hydra-client 2.2.1 → 2.4.0.alpha1

data/vendor/bundle/ruby/3.1.0/gems/rspec-expectations-3.13.1/lib/rspec/matchers/built_in/count_expectation.rb

@@ -1,169 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Abstract class to implement `once`, `at_least` and other
-      # count constraints.
-      module CountExpectation
-        # @api public
-        # Specifies that the method is expected to match once.
-        def once
-          exactly(1)
-        end
-
-        # @api public
-        # Specifies that the method is expected to match twice.
-        def twice
-          exactly(2)
-        end
-
-        # @api public
-        # Specifies that the method is expected to match thrice.
-        def thrice
-          exactly(3)
-        end
-
-        # @api public
-        # Specifies that the method is expected to match the given number of times.
-        def exactly(number)
-          set_expected_count(:==, number)
-          self
-        end
-
-        # @api public
-        # Specifies the maximum number of times the method is expected to match
-        def at_most(number)
-          set_expected_count(:<=, number)
-          self
-        end
-
-        # @api public
-        # Specifies the minimum number of times the method is expected to match
-        def at_least(number)
-          set_expected_count(:>=, number)
-          self
-        end
-
-        # @api public
-        # No-op. Provides syntactic sugar.
-        def times
-          self
-        end
-
-      protected
-        # @api private
-        attr_reader :count_expectation_type, :expected_count
-
-      private
-
-        if RUBY_VERSION.to_f > 1.8
-          def cover?(count, number)
-            count.cover?(number)
-          end
-        else
-          def cover?(count, number)
-            number >= count.first && number <= count.last
-          end
-        end
-
-        def expected_count_matches?(actual_count)
-          @actual_count = actual_count
-          return @actual_count > 0 unless count_expectation_type
-          return cover?(expected_count, actual_count) if count_expectation_type == :<=>
-
-          @actual_count.__send__(count_expectation_type, expected_count)
-        end
-
-        def has_expected_count?
-          !!count_expectation_type
-        end
-
-        def set_expected_count(relativity, n)
-          raise_unsupported_count_expectation if unsupported_count_expectation?(relativity)
-
-          count = count_constraint_to_number(n)
-
-          if count_expectation_type == :<= && relativity == :>=
-            raise_impossible_count_expectation(count) if count > expected_count
-            @count_expectation_type = :<=>
-            @expected_count = count..expected_count
-          elsif count_expectation_type == :>= && relativity == :<=
-            raise_impossible_count_expectation(count) if count < expected_count
-            @count_expectation_type = :<=>
-            @expected_count = expected_count..count
-          else
-            @count_expectation_type = relativity
-            @expected_count = count
-          end
-        end
-
-        def raise_impossible_count_expectation(count)
-          text =
-            case count_expectation_type
-            when :<= then "at_least(#{count}).at_most(#{expected_count})"
-            when :>= then "at_least(#{expected_count}).at_most(#{count})"
-            end
-          raise ArgumentError, "The constraint #{text} is not possible"
-        end
-
-        def raise_unsupported_count_expectation
-          text =
-            case count_expectation_type
-            when :<= then "at_least"
-            when :>= then "at_most"
-            when :<=> then "at_least/at_most combination"
-            else "count"
-            end
-          raise ArgumentError, "Multiple #{text} constraints are not supported"
-        end
-
-        def count_constraint_to_number(n)
-          case n
-          when Numeric then n
-          when :once then 1
-          when :twice then 2
-          when :thrice then 3
-          else
-            raise ArgumentError, "Expected a number, :once, :twice or :thrice," \
-              " but got #{n}"
-          end
-        end
-
-        def unsupported_count_expectation?(relativity)
-          return true if count_expectation_type == :==
-          return true if count_expectation_type == :<=>
-          (count_expectation_type == :<= && relativity == :<=) ||
-            (count_expectation_type == :>= && relativity == :>=)
-        end
-
-        def count_expectation_description
-          "#{human_readable_expectation_type}#{human_readable_count(expected_count)}"
-        end
-
-        def count_failure_reason(action)
-          "#{count_expectation_description}" \
-          " but #{action}#{human_readable_count(@actual_count)}"
-        end
-
-        def human_readable_expectation_type
-          case count_expectation_type
-          when :<= then ' at most'
-          when :>= then ' at least'
-          when :<=> then ' between'
-          else ''
-          end
-        end
-
-        def human_readable_count(count)
-          case count
-          when Range then " #{count.first} and #{count.last} times"
-          when nil then ''
-          when 1 then ' once'
-          when 2 then ' twice'
-          else " #{count} times"
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rspec-expectations-3.13.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/3.1.0/gems/rspec-expectations-3.13.1/lib/rspec/matchers/built_in/include.rb

@@ -1,213 +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).
-
-          has_exact_key =
-            begin
-              actual.key?(expected_key)
-            rescue
-              false
-            end
-
-          has_exact_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(Hash === expected ? expected : 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/3.1.0/gems/rspec-expectations-3.13.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

data/vendor/bundle/ruby/3.1.0/gems/rspec-expectations-3.13.1/lib/rspec/matchers/built_in/satisfy.rb

@@ -1,60 +0,0 @@
-module RSpec
-  module Matchers
-    module BuiltIn
-      # @api private
-      # Provides the implementation for `satisfy`.
-      # Not intended to be instantiated directly.
-      class Satisfy < BaseMatcher
-        def initialize(description=nil, &block)
-          @description = description
-          @block = block
-        end
-
-        # @private
-        def matches?(actual, &block)
-          @block = block if block
-          @actual = actual
-          @block.call(actual)
-        end
-
-        # @private
-        def description
-          @description ||= "satisfy #{block_representation}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message
-          "expected #{actual_formatted} to #{description}"
-        end
-
-        # @api private
-        # @return [String]
-        def failure_message_when_negated
-          "expected #{actual_formatted} not to #{description}"
-        end
-
-      private
-
-        if RSpec::Support::RubyFeatures.ripper_supported?
-          def block_representation
-            if (block_snippet = extract_block_snippet)
-              "expression `#{block_snippet}`"
-            else
-              'block'
-            end
-          end
-
-          def extract_block_snippet
-            return nil unless @block
-            Expectations::BlockSnippetExtractor.try_extracting_single_line_body_of(@block, matcher_name)
-          end
-        else
-          def block_representation
-            'block'
-          end
-        end
-      end
-    end
-  end
-end