@pact-foundation/pact-core 13.8.0 → 13.9.1

package/standalone/linux-x64-1.89.02-rc1/pact/lib/vendor/ruby/2.4.0/gems/faraday-0.17.5/lib/faraday/utils.rb

@@ -1,326 +0,0 @@
-require 'thread'
-
-module Faraday
-  module Utils
-    extend self
-
-    # Adapted from Rack::Utils::HeaderHash
-    class Headers < ::Hash
-      def self.from(value)
-        new(value)
-      end
-
-      def self.allocate
-        new_self = super
-        new_self.initialize_names
-        new_self
-      end
-
-      def initialize(hash = nil)
-        super()
-        @names = {}
-        self.update(hash || {})
-      end
-
-      def initialize_names
-        @names = {}
-      end
-
-      # on dup/clone, we need to duplicate @names hash
-      def initialize_copy(other)
-        super
-        @names = other.names.dup
-      end
-
-      # need to synchronize concurrent writes to the shared KeyMap
-      keymap_mutex = Mutex.new
-
-      # symbol -> string mapper + cache
-      KeyMap = Hash.new do |map, key|
-        value = if key.respond_to?(:to_str)
-          key
-        else
-          key.to_s.split('_').            # :user_agent => %w(user agent)
-            each { |w| w.capitalize! }.   # => %w(User Agent)
-            join('-')                     # => "User-Agent"
-        end
-        keymap_mutex.synchronize { map[key] = value }
-      end
-      KeyMap[:etag] = "ETag"
-
-      def [](k)
-        k = KeyMap[k]
-        super(k) || super(@names[k.downcase])
-      end
-
-      def []=(k, v)
-        k = KeyMap[k]
-        k = (@names[k.downcase] ||= k)
-        # join multiple values with a comma
-        v = v.to_ary.join(', ') if v.respond_to? :to_ary
-        super(k, v)
-      end
-
-      def fetch(k, *args, &block)
-        k = KeyMap[k]
-        key = @names.fetch(k.downcase, k)
-        super(key, *args, &block)
-      end
-
-      def delete(k)
-        k = KeyMap[k]
-        if k = @names[k.downcase]
-          @names.delete k.downcase
-          super(k)
-        end
-      end
-
-      def include?(k)
-        @names.include? k.downcase
-      end
-
-      alias_method :has_key?, :include?
-      alias_method :member?, :include?
-      alias_method :key?, :include?
-
-      def merge!(other)
-        other.each { |k, v| self[k] = v }
-        self
-      end
-      alias_method :update, :merge!
-
-      def merge(other)
-        hash = dup
-        hash.merge! other
-      end
-
-      def replace(other)
-        clear
-        @names.clear
-        self.update other
-        self
-      end
-
-      def to_hash() ::Hash.new.update(self) end
-
-      def parse(header_string)
-        return unless header_string && !header_string.empty?
-
-        headers = header_string.split(/\r\n/)
-
-        # Find the last set of response headers.
-        start_index = headers.rindex { |x| x.match(/^HTTP\//) } || 0
-        last_response = headers.slice(start_index, headers.size)
-
-        last_response.
-          tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
-          map  { |h| h.split(/:\s*/, 2) }.reject { |p| p[0].nil? }. # split key and value, ignore blank lines
-          each { |key, value|
-            # join multiple values with a comma
-            if self[key]
-              self[key] << ', ' << value
-            else
-              self[key] = value
-            end
-          }
-      end
-
-      protected
-
-      def names
-        @names
-      end
-    end
-
-    # hash with stringified keys
-    class ParamsHash < Hash
-      def [](key)
-        super(convert_key(key))
-      end
-
-      def []=(key, value)
-        super(convert_key(key), value)
-      end
-
-      def delete(key)
-        super(convert_key(key))
-      end
-
-      def include?(key)
-        super(convert_key(key))
-      end
-
-      alias_method :has_key?, :include?
-      alias_method :member?, :include?
-      alias_method :key?, :include?
-
-      def update(params)
-        params.each do |key, value|
-          self[key] = value
-        end
-        self
-      end
-      alias_method :merge!, :update
-
-      def merge(params)
-        dup.update(params)
-      end
-
-      def replace(other)
-        clear
-        update(other)
-      end
-
-      def merge_query(query, encoder = nil)
-        if query && !query.empty?
-          update((encoder || Utils.default_params_encoder).decode(query))
-        end
-        self
-      end
-
-      def to_query(encoder = nil)
-        (encoder || Utils.default_params_encoder).encode(self)
-      end
-
-      private
-
-      def convert_key(key)
-        key.to_s
-      end
-    end
-
-    def build_query(params)
-      FlatParamsEncoder.encode(params)
-    end
-
-    def build_nested_query(params)
-      NestedParamsEncoder.encode(params)
-    end
-
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
-
-    def escape(s)
-      s.to_s.gsub(ESCAPE_RE) {|match|
-        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    def unescape(s) CGI.unescape s.to_s end
-
-    DEFAULT_SEP = /[&;] */n
-
-    # Adapted from Rack
-    def parse_query(query)
-      FlatParamsEncoder.decode(query)
-    end
-
-    def parse_nested_query(query)
-      NestedParamsEncoder.decode(query)
-    end
-
-    def default_params_encoder
-      @default_params_encoder ||= NestedParamsEncoder
-    end
-
-    class << self
-      attr_writer :default_params_encoder
-    end
-
-    # Stolen from Rack
-    def normalize_params(params, name, v = nil)
-      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
-      k = $1 || ''
-      after = $' || ''
-
-      return if k.empty?
-
-      if after == ""
-        if params[k]
-          params[k] = Array[params[k]] unless params[k].kind_of?(Array)
-          params[k] << v
-        else
-          params[k] = v
-        end
-      elsif after == "[]"
-        params[k] ||= []
-        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        params[k] << v
-      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
-        child_key = $1
-        params[k] ||= []
-        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
-          normalize_params(params[k].last, child_key, v)
-        else
-          params[k] << normalize_params({}, child_key, v)
-        end
-      else
-        params[k] ||= {}
-        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
-        params[k] = normalize_params(params[k], after, v)
-      end
-
-      return params
-    end
-
-    # Normalize URI() behavior across Ruby versions
-    #
-    # url - A String or URI.
-    #
-    # Returns a parsed URI.
-    def URI(url)
-      if url.respond_to?(:host)
-        url
-      elsif url.respond_to?(:to_str)
-        default_uri_parser.call(url)
-      else
-        raise ArgumentError, "bad argument (expected URI object or URI string)"
-      end
-    end
-
-    def default_uri_parser
-      @default_uri_parser ||= begin
-        require 'uri'
-        Kernel.method(:URI)
-      end
-    end
-
-    def default_uri_parser=(parser)
-      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
-        parser
-      else
-        parser.method(:parse)
-      end
-    end
-
-    # Receives a String or URI and returns just the path with the query string sorted.
-    def normalize_path(url)
-      url = URI(url)
-      (url.path.start_with?('/') ? url.path : '/' + url.path) +
-      (url.query ? "?#{sort_query_params(url.query)}" : "")
-    end
-
-    # Recursive hash update
-    def deep_merge!(target, hash)
-      hash.each do |key, value|
-        if Hash === value and Hash === target[key]
-          target[key] = deep_merge(target[key], value)
-        else
-          target[key] = value
-        end
-      end
-      target
-    end
-
-    # Recursive hash merge
-    def deep_merge(source, hash)
-      deep_merge!(source.dup, hash)
-    end
-
-    protected
-
-    def sort_query_params(query)
-      query.split('&').sort.join('&')
-    end
-  end
-end

package/standalone/linux-x64-1.89.02-rc1/pact/lib/vendor/ruby/2.4.0/gems/faraday-0.17.5/lib/faraday.rb

@@ -1,247 +0,0 @@
-require 'thread'
-require 'cgi'
-require 'set'
-require 'forwardable'
-
-# Public: This is the main namespace for Faraday.  You can either use it to
-# create Faraday::Connection objects, or access it directly.
-#
-# Examples
-#
-#   Faraday.get "http://faraday.com"
-#
-#   conn = Faraday.new "http://faraday.com"
-#   conn.get '/'
-#
-module Faraday
-  VERSION = "0.17.5"
-
-  class << self
-    # Public: Gets or sets the root path that Faraday is being loaded from.
-    # This is the root from where the libraries are auto-loaded from.
-    attr_accessor :root_path
-
-    # Public: Gets or sets the path that the Faraday libs are loaded from.
-    attr_accessor :lib_path
-
-    # Public: Gets or sets the Symbol key identifying a default Adapter to use
-    # for the default Faraday::Connection.
-    attr_reader :default_adapter
-
-    # Public: Sets the default Faraday::Connection for simple scripts that
-    # access the Faraday constant directly.
-    #
-    #     Faraday.get "https://faraday.com"
-    attr_writer :default_connection
-
-    # Public: Tells faraday to ignore the environment proxy (http_proxy).
-    attr_accessor :ignore_env_proxy
-
-    # Public: Initializes a new Faraday::Connection.
-    #
-    # url     - The optional String base URL to use as a prefix for all
-    #           requests.  Can also be the options Hash.
-    # options - The optional Hash used to configure this Faraday::Connection.
-    #           Any of these values will be set on every request made, unless
-    #           overridden for a specific request.
-    #           :url     - String base URL.
-    #           :params  - Hash of URI query unencoded key/value pairs.
-    #           :headers - Hash of unencoded HTTP header key/value pairs.
-    #           :request - Hash of request options.
-    #           :ssl     - Hash of SSL options.
-    #           :proxy   - Hash of Proxy options.
-    #
-    # Examples
-    #
-    #   Faraday.new 'http://faraday.com'
-    #
-    #   # http://faraday.com?page=1
-    #   Faraday.new 'http://faraday.com', :params => {:page => 1}
-    #
-    #   # same
-    #
-    #   Faraday.new :url => 'http://faraday.com',
-    #     :params => {:page => 1}
-    #
-    # Returns a Faraday::Connection.
-    def new(url = nil, options = nil, &block)
-      options = options ? default_connection_options.merge(options) : default_connection_options
-      Faraday::Connection.new(url, options, &block)
-    end
-
-    # Internal: Requires internal Faraday libraries.
-    #
-    # *libs - One or more relative String names to Faraday classes.
-    #
-    # Returns nothing.
-    def require_libs(*libs)
-      libs.each do |lib|
-        require "#{lib_path}/#{lib}"
-      end
-    end
-
-    # Public: Updates default adapter while resetting
-    # #default_connection.
-    #
-    # Returns the new default_adapter.
-    def default_adapter=(adapter)
-      @default_connection = nil
-      @default_adapter = adapter
-    end
-
-    alias require_lib require_libs
-
-    def respond_to?(symbol, include_private = false)
-      default_connection.respond_to?(symbol, include_private) || super
-    end
-
-  private
-    # Internal: Proxies method calls on the Faraday constant to
-    # #default_connection.
-    def method_missing(name, *args, &block)
-      default_connection.send(name, *args, &block)
-    end
-  end
-
-  self.ignore_env_proxy = false
-  self.root_path = File.expand_path "..", __FILE__
-  self.lib_path = File.expand_path "../faraday", __FILE__
-  self.default_adapter = :net_http
-
-  # Gets the default connection used for simple scripts.
-  #
-  # Returns a Faraday::Connection, configured with the #default_adapter.
-  def self.default_connection
-    @default_connection ||= Connection.new(default_connection_options)
-  end
-
-  # Gets the default connection options used when calling Faraday#new.
-  #
-  # Returns a Faraday::ConnectionOptions.
-  def self.default_connection_options
-    @default_connection_options ||= ConnectionOptions.new
-  end
-
-  # Public: Sets the default options used when calling Faraday#new.
-  def self.default_connection_options=(options)
-    @default_connection = nil
-    @default_connection_options = ConnectionOptions.from(options)
-  end
-
-  unless const_defined? :Timer
-    require 'timeout'
-    Timer = Timeout
-  end
-
-  # Public: Adds the ability for other modules to register and lookup
-  # middleware classes.
-  module MiddlewareRegistry
-    # Public: Register middleware class(es) on the current module.
-    #
-    # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
-    #           as fully qualified constant, or a Proc that will be lazily
-    #           called to return the former.
-    #
-    # Examples
-    #
-    #   module Faraday
-    #     class Whatever
-    #       # Middleware looked up by :foo returns Faraday::Whatever::Foo.
-    #       register_middleware :foo => Foo
-    #
-    #       # Middleware looked up by :bar returns Faraday::Whatever.const_get(:Bar)
-    #       register_middleware :bar => :Bar
-    #
-    #       # Middleware looked up by :baz requires 'baz' and returns Faraday::Whatever.const_get(:Baz)
-    #       register_middleware :baz => [:Baz, 'baz']
-    #     end
-    #   end
-    #
-    # Returns nothing.
-    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
-
-    # Public: Lookup middleware class with a registered Symbol shortcut.
-    #
-    # key - The Symbol key for the registered middleware.
-    #
-    # Examples
-    #
-    #   module Faraday
-    #     class Whatever
-    #       register_middleware :foo => Foo
-    #     end
-    #   end
-    #
-    #   Faraday::Whatever.lookup_middleware(:foo)
-    #   # => Faraday::Whatever::Foo
-    #
-    # Returns a middleware Class.
-    def lookup_middleware(key)
-      load_middleware(key) ||
-        raise(Faraday::Error.new("#{key.inspect} is not registered on #{self}"))
-    end
-
-    def middleware_mutex(&block)
-      @middleware_mutex ||= begin
-        require 'monitor'
-        Monitor.new
-      end
-      @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
-
-  def self.const_missing(name)
-    if name.to_sym == :Builder
-      warn "Faraday::Builder is now Faraday::RackBuilder."
-      const_set name, RackBuilder
-    else
-      super
-    end
-  end
-
-  require_libs "utils", "options", "connection", "rack_builder", "parameters",
-    "middleware", "adapter", "request", "response", "upload_io", "error"
-
-  if !ENV["FARADAY_NO_AUTOLOAD"]
-    require_lib 'autoload'
-  end
-end

package/standalone/linux-x64-1.89.02-rc1/pact/lib/vendor/ruby/2.4.0/gems/faraday_middleware-0.14.0/lib/faraday_middleware/backwards_compatibility.rb

@@ -1,18 +0,0 @@
-# deprecated constants
-
-module Faraday
-  class Request
-    autoload :OAuth,        'faraday_middleware/request/oauth'
-    autoload :OAuth2,       'faraday_middleware/request/oauth2'
-  end
-
-  class Response
-    autoload :Mashify,      'faraday_middleware/response/mashify'
-    autoload :Rashify,      'faraday_middleware/response/rashify'
-    autoload :ParseJson,    'faraday_middleware/response/parse_json'
-    autoload :ParseXml,     'faraday_middleware/response/parse_xml'
-    autoload :ParseMarshal, 'faraday_middleware/response/parse_marshal'
-    autoload :ParseYaml,    'faraday_middleware/response/parse_yaml'
-  end
-end
-

package/standalone/linux-x64-1.89.02-rc1/pact/lib/vendor/ruby/2.4.0/gems/faraday_middleware-0.14.0/lib/faraday_middleware/gzip.rb

@@ -1,93 +0,0 @@
-require 'faraday'
-
-module FaradayMiddleware
-  # Middleware to automatically decompress response bodies. If the
-  # "Accept-Encoding" header wasn't set in the request, this sets it to
-  # "gzip,deflate" and appropriately handles the compressed response from the
-  # server. This resembles what Ruby 1.9+ does internally in Net::HTTP#get.
-  #
-  # This middleware is NOT necessary when these adapters are used:
-  # - net_http on Ruby 1.9+
-  # - net_http_persistent on Ruby 2.0+
-  # - em_http
-  class Gzip < Faraday::Middleware
-    dependency 'zlib'
-
-    def self.optional_dependency(lib = nil)
-      lib ? require(lib) : yield
-      true
-    rescue LoadError, NameError
-      false
-    end
-
-    BROTLI_SUPPORTED = optional_dependency 'brotli'
-
-    def self.supported_encodings
-      encodings = %w[gzip deflate]
-      encodings << 'br' if BROTLI_SUPPORTED
-      encodings
-    end
-
-    ACCEPT_ENCODING = 'Accept-Encoding'.freeze
-    CONTENT_ENCODING = 'Content-Encoding'.freeze
-    CONTENT_LENGTH = 'Content-Length'.freeze
-    SUPPORTED_ENCODINGS = supported_encodings.join(',').freeze
-    RUBY_ENCODING = '1.9'.respond_to?(:force_encoding)
-
-    def call(env)
-      env[:request_headers][ACCEPT_ENCODING] ||= SUPPORTED_ENCODINGS
-      @app.call(env).on_complete do |response_env|
-        if response_env[:body].empty?
-          reset_body(response_env, &method(:raw_body))
-        else
-          case response_env[:response_headers][CONTENT_ENCODING]
-          when 'gzip'
-            reset_body(response_env, &method(:uncompress_gzip))
-          when 'deflate'
-            reset_body(response_env, &method(:inflate))
-          when 'br'
-            reset_body(response_env, &method(:brotli_inflate))
-          end
-        end
-      end
-    end
-
-    def reset_body(env)
-      env[:body] = yield(env[:body])
-      env[:response_headers].delete(CONTENT_ENCODING)
-      env[:response_headers][CONTENT_LENGTH] = env[:body].length
-    end
-
-    def uncompress_gzip(body)
-      io = StringIO.new(body)
-      gzip_reader = if RUBY_ENCODING
-        Zlib::GzipReader.new(io, :encoding => 'ASCII-8BIT')
-      else
-        Zlib::GzipReader.new(io)
-      end
-      gzip_reader.read
-    end
-
-    def inflate(body)
-      # Inflate as a DEFLATE (RFC 1950+RFC 1951) stream
-      Zlib::Inflate.inflate(body)
-    rescue Zlib::DataError
-      # Fall back to inflating as a "raw" deflate stream which
-      # Microsoft servers return
-      inflate = Zlib::Inflate.new(-Zlib::MAX_WBITS)
-      begin
-        inflate.inflate(body)
-      ensure
-        inflate.close
-      end
-    end
-
-    def brotli_inflate(body)
-      Brotli.inflate(body)
-    end
-
-    def raw_body(body)
-      body
-    end
-  end
-end

package/standalone/linux-x64-1.89.02-rc1/pact/lib/vendor/ruby/2.4.0/gems/faraday_middleware-0.14.0/lib/faraday_middleware/instrumentation.rb

@@ -1,30 +0,0 @@
-require 'faraday'
-
-module FaradayMiddleware
-  # Public: Instruments requests using Active Support.
-  #
-  # Measures time spent only for synchronous requests.
-  #
-  # Examples
-  #
-  #   ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
-  #     url = env[:url]
-  #     http_method = env[:method].to_s.upcase
-  #     duration = ends - starts
-  #     $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
-  #   end
-  class Instrumentation < Faraday::Middleware
-    dependency 'active_support/notifications'
-
-    def initialize(app, options = {})
-      super(app)
-      @name = options.fetch(:name, 'request.faraday')
-    end
-
-    def call(env)
-      ::ActiveSupport::Notifications.instrument(@name, env) do
-        @app.call(env)
-      end
-    end
-  end
-end