@pact-foundation/pact-core 14.0.4 → 14.0.6

package/standalone/darwin-arm64-2.0.3/pact/lib/vendor/ruby/3.2.0/gems/faraday-1.10.3/lib/faraday/deprecate.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # @param new_klass [Class] new Klass to use
-  #
-  # @return [Class] A modified version of new_klass that warns on
-  #   usage about deprecation.
-  # @see Faraday::Deprecate
-  module DeprecatedClass
-    def self.proxy_class(origclass, ver = '1.0')
-      proxy = Class.new(origclass) do
-        const_set('ORIG_CLASS', origclass)
-
-        class << self
-          extend Faraday::Deprecate
-
-          def ===(other)
-            (superclass == const_get('ORIG_CLASS') && other.is_a?(superclass)) || super
-          end
-        end
-      end
-      proxy.singleton_class.send(:deprecate, :new, "#{origclass}.new", ver)
-      proxy.singleton_class.send(:deprecate, :inherited, origclass.name, ver)
-      proxy
-    end
-  end
-
-  # Deprecation using semver instead of date, based on Gem::Deprecate
-  # Provides a single method +deprecate+ to be used to declare when
-  # something is going away.
-  #
-  #     class Legacy
-  #       def self.klass_method
-  #         # ...
-  #       end
-  #
-  #       def instance_method
-  #         # ...
-  #       end
-  #
-  #       extend Faraday::Deprecate
-  #       deprecate :instance_method, "X.z", '1.0'
-  #
-  #       class << self
-  #         extend Faraday::Deprecate
-  #         deprecate :klass_method, :none, '1.0'
-  #       end
-  #     end
-  module Deprecate
-    def self.skip # :nodoc:
-      @skip ||= begin
-        case ENV['FARADAY_DEPRECATE'].to_s.downcase
-        when '1', 'warn' then :warn
-        else :skip
-        end
-      end
-      @skip == :skip
-    end
-
-    def self.skip=(value) # :nodoc:
-      @skip = value ? :skip : :warn
-    end
-
-    # Temporarily turn off warnings. Intended for tests only.
-    def skip_during
-      original = Faraday::Deprecate.skip
-      Faraday::Deprecate.skip = true
-      yield
-    ensure
-      Faraday::Deprecate.skip = original
-    end
-
-    # Simple deprecation method that deprecates +name+ by wrapping it up
-    # in a dummy method. It warns on each call to the dummy method
-    # telling the user of +repl+ (unless +repl+ is :none) and the
-    # semver that it is planned to go away.
-    # @param name [Symbol] the method symbol to deprecate
-    # @param repl [#to_s, :none] the replacement to use, when `:none` it will
-    #   alert the user that no replacement is present.
-    # @param ver [String] the semver the method will be removed.
-    def deprecate(name, repl, ver, custom_message = nil)
-      class_eval do
-        gem_ver = Gem::Version.new(ver)
-        old = "_deprecated_#{name}"
-        alias_method old, name
-        define_method name do |*args, &block|
-          mod = is_a? Module
-          target = mod ? "#{self}." : "#{self.class}#"
-          target_message = if name == :inherited
-                             "Inheriting #{self}"
-                           else
-                             "#{target}#{name}"
-                           end
-
-          msg = [
-            "NOTE: #{target_message} is deprecated",
-            repl == :none ? ' with no replacement' : "; use #{repl} instead. ",
-            "It will be removed in or after version #{gem_ver} ",
-            custom_message,
-            "\n#{target}#{name} called from #{Gem.location_of_caller.join(':')}"
-          ]
-          warn "#{msg.join}." unless Faraday::Deprecate.skip
-          send old, *args, &block
-        end
-      end
-    end
-
-    module_function :deprecate, :skip_during
-  end
-end

package/standalone/darwin-arm64-2.0.3/pact/lib/vendor/ruby/3.2.0/gems/faraday-1.10.3/lib/faraday/encoders/nested_params_encoder.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Sub-module for encoding parameters into query-string.
-  module EncodeMethods
-    # @param params [nil, Array, #to_hash] parameters to be encoded
-    #
-    # @return [String] the encoded params
-    #
-    # @raise [TypeError] if params can not be converted to a Hash
-    def encode(params)
-      return nil if params.nil?
-
-      unless params.is_a?(Array)
-        unless params.respond_to?(:to_hash)
-          raise TypeError, "Can't convert #{params.class} into Hash."
-        end
-
-        params = params.to_hash
-        params = params.map do |key, value|
-          key = key.to_s if key.is_a?(Symbol)
-          [key, value]
-        end
-
-        # Only to be used for non-Array inputs. Arrays should preserve order.
-        params.sort! if @sort_params
-      end
-
-      # The params have form [['key1', 'value1'], ['key2', 'value2']].
-      buffer = +''
-      params.each do |parent, value|
-        encoded_parent = escape(parent)
-        buffer << "#{encode_pair(encoded_parent, value)}&"
-      end
-      buffer.chop
-    end
-
-    protected
-
-    def encode_pair(parent, value)
-      if value.is_a?(Hash)
-        encode_hash(parent, value)
-      elsif value.is_a?(Array)
-        encode_array(parent, value)
-      elsif value.nil?
-        parent
-      else
-        encoded_value = escape(value)
-        "#{parent}=#{encoded_value}"
-      end
-    end
-
-    def encode_hash(parent, value)
-      value = value.map { |key, val| [escape(key), val] }.sort
-
-      buffer = +''
-      value.each do |key, val|
-        new_parent = "#{parent}%5B#{key}%5D"
-        buffer << "#{encode_pair(new_parent, val)}&"
-      end
-      buffer.chop
-    end
-
-    def encode_array(parent, value)
-      new_parent = "#{parent}%5B%5D"
-      return new_parent if value.empty?
-
-      buffer = +''
-      value.each { |val| buffer << "#{encode_pair(new_parent, val)}&" }
-      buffer.chop
-    end
-  end
-
-  # Sub-module for decoding query-string into parameters.
-  module DecodeMethods
-    # @param query [nil, String]
-    #
-    # @return [Array<Array, String>] the decoded params
-    #
-    # @raise [TypeError] if the nesting is incorrect
-    def decode(query)
-      return nil if query.nil?
-
-      params = {}
-      query.split('&').each do |pair|
-        next if pair.empty?
-
-        key, value = pair.split('=', 2)
-        key = unescape(key)
-        value = unescape(value.tr('+', ' ')) if value
-        decode_pair(key, value, params)
-      end
-
-      dehash(params, 0)
-    end
-
-    protected
-
-    SUBKEYS_REGEX = /[^\[\]]+(?:\]?\[\])?/.freeze
-
-    def decode_pair(key, value, context)
-      subkeys = key.scan(SUBKEYS_REGEX)
-      subkeys.each_with_index do |subkey, i|
-        is_array = subkey =~ /[\[\]]+\Z/
-        subkey = $` if is_array
-        last_subkey = i == subkeys.length - 1
-
-        context = prepare_context(context, subkey, is_array, last_subkey)
-        add_to_context(is_array, context, value, subkey) if last_subkey
-      end
-    end
-
-    def prepare_context(context, subkey, is_array, last_subkey)
-      if !last_subkey || is_array
-        context = new_context(subkey, is_array, context)
-      end
-      if context.is_a?(Array) && !is_array
-        context = match_context(context, subkey)
-      end
-      context
-    end
-
-    def new_context(subkey, is_array, context)
-      value_type = is_array ? Array : Hash
-      if context[subkey] && !context[subkey].is_a?(value_type)
-        raise TypeError, "expected #{value_type.name} " \
-          "(got #{context[subkey].class.name}) for param `#{subkey}'"
-      end
-
-      context[subkey] ||= value_type.new
-    end
-
-    def match_context(context, subkey)
-      context << {} if !context.last.is_a?(Hash) || context.last.key?(subkey)
-      context.last
-    end
-
-    def add_to_context(is_array, context, value, subkey)
-      is_array ? context << value : context[subkey] = value
-    end
-
-    # Internal: convert a nested hash with purely numeric keys into an array.
-    # FIXME: this is not compatible with Rack::Utils.parse_nested_query
-    # @!visibility private
-    def dehash(hash, depth)
-      hash.each do |key, value|
-        hash[key] = dehash(value, depth + 1) if value.is_a?(Hash)
-      end
-
-      if depth.positive? && !hash.empty? && hash.keys.all? { |k| k =~ /^\d+$/ }
-        hash.sort.map(&:last)
-      else
-        hash
-      end
-    end
-  end
-
-  # This is the default encoder for Faraday requests.
-  # Using this encoder, parameters will be encoded respecting their structure,
-  # so you can send objects such as Arrays or Hashes as parameters
-  # for your requests.
-  module NestedParamsEncoder
-    class << self
-      attr_accessor :sort_params
-
-      extend Forwardable
-      def_delegators :'Faraday::Utils', :escape, :unescape
-    end
-
-    # Useful default for OAuth and caching.
-    @sort_params = true
-
-    extend EncodeMethods
-    extend DecodeMethods
-  end
-end

package/standalone/darwin-arm64-2.0.3/pact/lib/vendor/ruby/3.2.0/gems/faraday-1.10.3/lib/faraday/error.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-# Faraday namespace.
-module Faraday
-  # Faraday error base class.
-  class Error < StandardError
-    attr_reader :response, :wrapped_exception
-
-    def initialize(exc, response = nil)
-      @wrapped_exception = nil unless defined?(@wrapped_exception)
-      @response = nil unless defined?(@response)
-      super(exc_msg_and_response!(exc, response))
-    end
-
-    def backtrace
-      if @wrapped_exception
-        @wrapped_exception.backtrace
-      else
-        super
-      end
-    end
-
-    def inspect
-      inner = +''
-      inner << " wrapped=#{@wrapped_exception.inspect}" if @wrapped_exception
-      inner << " response=#{@response.inspect}" if @response
-      inner << " #{super}" if inner.empty?
-      %(#<#{self.class}#{inner}>)
-    end
-
-    def response_status
-      @response[:status] if @response
-    end
-
-    def response_headers
-      @response[:headers] if @response
-    end
-
-    def response_body
-      @response[:body] if @response
-    end
-
-    protected
-
-    # Pulls out potential parent exception and response hash, storing them in
-    # instance variables.
-    # exc      - Either an Exception, a string message, or a response hash.
-    # response - Hash
-    #              :status  - Optional integer HTTP response status
-    #              :headers - String key/value hash of HTTP response header
-    #                         values.
-    #              :body    - Optional string HTTP response body.
-    #              :request - Hash
-    #                           :method   - Symbol with the request HTTP method.
-    #                           :url_path - String with the url path requested.
-    #                           :params   - String key/value hash of query params
-    #                                     present in the request.
-    #                           :headers  - String key/value hash of HTTP request
-    #                                     header values.
-    #                           :body     - String HTTP request body.
-    #
-    # If a subclass has to call this, then it should pass a string message
-    # to `super`. See NilStatusError.
-    def exc_msg_and_response!(exc, response = nil)
-      if @response.nil? && @wrapped_exception.nil?
-        @wrapped_exception, msg, @response = exc_msg_and_response(exc, response)
-        return msg
-      end
-
-      exc.to_s
-    end
-
-    # Pulls out potential parent exception and response hash.
-    def exc_msg_and_response(exc, response = nil)
-      return [exc, exc.message, response] if exc.respond_to?(:backtrace)
-
-      return [nil, "the server responded with status #{exc[:status]}", exc] \
-        if exc.respond_to?(:each_key)
-
-      [nil, exc.to_s, response]
-    end
-  end
-
-  # Faraday client error class. Represents 4xx status responses.
-  class ClientError < Error
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 400 response.
-  class BadRequestError < ClientError
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 401 response.
-  class UnauthorizedError < ClientError
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 403 response.
-  class ForbiddenError < ClientError
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 404 response.
-  class ResourceNotFound < ClientError
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 407 response.
-  class ProxyAuthError < ClientError
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 409 response.
-  class ConflictError < ClientError
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a 422 response.
-  class UnprocessableEntityError < ClientError
-  end
-
-  # Faraday server error class. Represents 5xx status responses.
-  class ServerError < Error
-  end
-
-  # A unified client error for timeouts.
-  class TimeoutError < ServerError
-    def initialize(exc = 'timeout', response = nil)
-      super(exc, response)
-    end
-  end
-
-  # Raised by Faraday::Response::RaiseError in case of a nil status in response.
-  class NilStatusError < ServerError
-    def initialize(exc, response = nil)
-      exc_msg_and_response!(exc, response)
-      super('http status could not be derived from the server response')
-    end
-  end
-
-  # A unified error for failed connections.
-  class ConnectionFailed < Error
-  end
-
-  # A unified client error for SSL errors.
-  class SSLError < Error
-  end
-
-  # Raised by FaradayMiddleware::ResponseMiddleware
-  class ParsingError < Error
-  end
-end

package/standalone/darwin-arm64-2.0.3/pact/lib/vendor/ruby/3.2.0/gems/faraday-1.10.3/lib/faraday/logging/formatter.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-module Faraday
-  module Logging
-    # Serves as an integration point to customize logging
-    class Formatter
-      extend Forwardable
-
-      DEFAULT_OPTIONS = { headers: true, bodies: false,
-                          log_level: :info }.freeze
-
-      def initialize(logger:, options:)
-        @logger = logger
-        @filter = []
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def_delegators :@logger, :debug, :info, :warn, :error, :fatal
-
-      def request(env)
-        request_log = proc do
-          "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
-        end
-        public_send(log_level, 'request', &request_log)
-
-        log_headers('request', env.request_headers) if log_headers?(:request)
-        log_body('request', env[:body]) if env[:body] && log_body?(:request)
-      end
-
-      def response(env)
-        status = proc { "Status #{env.status}" }
-        public_send(log_level, 'response', &status)
-
-        log_headers('response', env.response_headers) if log_headers?(:response)
-        log_body('response', env[:body]) if env[:body] && log_body?(:response)
-      end
-
-      def filter(filter_word, filter_replacement)
-        @filter.push([filter_word, filter_replacement])
-      end
-
-      private
-
-      def dump_headers(headers)
-        headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
-      end
-
-      def dump_body(body)
-        if body.respond_to?(:to_str)
-          body.to_str
-        else
-          pretty_inspect(body)
-        end
-      end
-
-      def pretty_inspect(body)
-        body.pretty_inspect
-      end
-
-      def log_headers?(type)
-        case @options[:headers]
-        when Hash
-          @options[:headers][type]
-        else
-          @options[:headers]
-        end
-      end
-
-      def log_body?(type)
-        case @options[:bodies]
-        when Hash
-          @options[:bodies][type]
-        else
-          @options[:bodies]
-        end
-      end
-
-      def apply_filters(output)
-        @filter.each do |pattern, replacement|
-          output = output.to_s.gsub(pattern, replacement)
-        end
-        output
-      end
-
-      def log_level
-        unless %i[debug info warn error fatal].include?(@options[:log_level])
-          return :info
-        end
-
-        @options[:log_level]
-      end
-
-      def log_headers(type, headers)
-        headers_log = proc { apply_filters(dump_headers(headers)) }
-        public_send(log_level, type, &headers_log)
-      end
-
-      def log_body(type, body)
-        body_log = proc { apply_filters(dump_body(body)) }
-        public_send(log_level, type, &body_log)
-      end
-    end
-  end
-end

package/standalone/darwin-arm64-2.0.3/pact/lib/vendor/ruby/3.2.0/gems/faraday-1.10.3/lib/faraday/middleware.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # Middleware is the basic base class of any Faraday middleware.
-  class Middleware
-    extend MiddlewareRegistry
-    extend DependencyLoader
-
-    attr_reader :app, :options
-
-    def initialize(app = nil, options = {})
-      @app = app
-      @options = options
-    end
-
-    def call(env)
-      on_request(env) if respond_to?(:on_request)
-      app.call(env).on_complete do |environment|
-        on_complete(environment) if respond_to?(:on_complete)
-      end
-    end
-
-    def close
-      if app.respond_to?(:close)
-        app.close
-      else
-        warn "#{app} does not implement \#close!"
-      end
-    end
-  end
-end

package/standalone/darwin-arm64-2.0.3/pact/lib/vendor/ruby/3.2.0/gems/faraday-1.10.3/lib/faraday/middleware_registry.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'monitor'
-
-module Faraday
-  # Adds the ability for other modules to register and lookup
-  # middleware classes.
-  module MiddlewareRegistry
-    # Register middleware class(es) on the current module.
-    #
-    # @param autoload_path [String] Middleware autoload path
-    # @param mapping [Hash{
-    #          Symbol => Module,
-    #          Symbol => Array<Module, Symbol, String>,
-    #        }] Middleware mapping from a lookup symbol to a reference to the
-    #        middleware.
-    #        Classes can be expressed as:
-    #          - a fully qualified constant
-    #          - a Symbol
-    #          - a Proc that will be lazily called to return the former
-    #          - an array is given, its first element is the constant or symbol,
-    #            and its second is a file to `require`.
-    # @return [void]
-    #
-    # @example Lookup by a constant
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
-    #       register_middleware foo: Foo
-    #     end
-    #   end
-    #
-    # @example Lookup by a symbol
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :bar returns
-    #       # Faraday::Whatever.const_get(:Bar)
-    #       register_middleware bar: :Bar
-    #     end
-    #   end
-    #
-    # @example Lookup by a symbol and string in an array
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :baz requires 'baz' and returns
-    #       # Faraday::Whatever.const_get(:Baz)
-    #       register_middleware baz: [:Baz, 'baz']
-    #     end
-    #   end
-    #
-    def register_middleware(autoload_path = nil, mapping = nil)
-      if mapping.nil?
-        mapping = autoload_path
-        autoload_path = nil
-      end
-      middleware_mutex do
-        @middleware_autoload_path = autoload_path if autoload_path
-        (@registered_middleware ||= {}).update(mapping)
-      end
-    end
-
-    # Unregister a previously registered middleware class.
-    #
-    # @param key [Symbol] key for the registered middleware.
-    def unregister_middleware(key)
-      @registered_middleware.delete(key)
-    end
-
-    # Lookup middleware class with a registered Symbol shortcut.
-    #
-    # @param key [Symbol] key for the registered middleware.
-    # @return [Class] a middleware Class.
-    # @raise [Faraday::Error] if given key is not registered
-    #
-    # @example
-    #
-    #   module Faraday
-    #     class Whatever
-    #       register_middleware foo: Foo
-    #     end
-    #   end
-    #
-    #   Faraday::Whatever.lookup_middleware(:foo)
-    #   # => Faraday::Whatever::Foo
-    #
-    def lookup_middleware(key)
-      load_middleware(key) ||
-        raise(Faraday::Error, "#{key.inspect} is not registered on #{self}")
-    end
-
-    def middleware_mutex(&block)
-      @middleware_mutex ||= Monitor.new
-      @middleware_mutex.synchronize(&block)
-    end
-
-    def fetch_middleware(key)
-      defined?(@registered_middleware) && @registered_middleware[key]
-    end
-
-    def load_middleware(key)
-      value = fetch_middleware(key)
-      case value
-      when Module
-        value
-      when Symbol, String
-        middleware_mutex do
-          @registered_middleware[key] = const_get(value)
-        end
-      when Proc
-        middleware_mutex do
-          @registered_middleware[key] = value.call
-        end
-      when Array
-        middleware_mutex do
-          const, path = value
-          if (root = @middleware_autoload_path)
-            path = "#{root}/#{path}"
-          end
-          require(path)
-          @registered_middleware[key] = const
-        end
-        load_middleware(key)
-      end
-    end
-  end
-end