@pact-foundation/pact-core 13.7.8 → 13.9.0

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

@@ -1,213 +0,0 @@
-require 'date'
-
-module Faraday
-  # Catches exceptions and retries each request a limited number of times.
-  #
-  # By default, it retries 2 times and handles only timeout exceptions. It can
-  # be configured with an arbitrary number of retries, a list of exceptions to
-  # handle, a retry interval, a percentage of randomness to add to the retry
-  # interval, and a backoff factor.
-  #
-  # Examples
-  #
-  #   Faraday.new do |conn|
-  #     conn.request :retry, max: 2, interval: 0.05,
-  #                          interval_randomness: 0.5, backoff_factor: 2,
-  #                          exceptions: [CustomException, 'Timeout::Error']
-  #     conn.adapter ...
-  #   end
-  #
-  # This example will result in a first interval that is random between 0.05 and 0.075 and a second
-  # interval that is random between 0.1 and 0.15
-  #
-  class Request::Retry < Faraday::Middleware
-    DEFAULT_EXCEPTIONS = [Errno::ETIMEDOUT, 'Timeout::Error',
-                          Faraday::TimeoutError, Faraday::RetriableResponse
-                         ].freeze
-    IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
-
-    class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
-                                         :backoff_factor, :exceptions, :methods, :retry_if, :retry_block,
-                                         :retry_statuses)
-
-      DEFAULT_CHECK = lambda { |env,exception| false }
-
-      def self.from(value)
-        if Integer === value
-          new(value)
-        else
-          super(value)
-        end
-      end
-
-      def max
-        (self[:max] ||= 2).to_i
-      end
-
-      def interval
-        (self[:interval] ||= 0).to_f
-      end
-
-      def max_interval
-        (self[:max_interval] ||= Float::MAX).to_f
-      end
-
-      def interval_randomness
-        (self[:interval_randomness] ||= 0).to_f
-      end
-
-      def backoff_factor
-        (self[:backoff_factor] ||= 1).to_f
-      end
-
-      def exceptions
-        Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
-      end
-
-      def methods
-        Array(self[:methods] ||= IDEMPOTENT_METHODS)
-      end
-
-      def retry_if
-        self[:retry_if] ||= DEFAULT_CHECK
-      end
-
-      def retry_block
-        self[:retry_block] ||= Proc.new {}
-      end
-
-      def retry_statuses
-        Array(self[:retry_statuses] ||= [])
-      end
-    end
-
-    # Public: Initialize middleware
-    #
-    # Options:
-    # max                 - Maximum number of retries (default: 2)
-    # interval            - Pause in seconds between retries (default: 0)
-    # interval_randomness - The maximum random interval amount expressed
-    #                       as a float between 0 and 1 to use in addition to the
-    #                       interval. (default: 0)
-    # max_interval        - An upper limit for the interval (default: Float::MAX)
-    # backoff_factor      - The amount to multiple each successive retry's
-    #                       interval amount by in order to provide backoff
-    #                       (default: 1)
-    # exceptions          - The list of exceptions to handle. Exceptions can be
-    #                       given as Class, Module, or String. (default:
-    #                       [Errno::ETIMEDOUT, 'Timeout::Error',
-    #                       Faraday::TimeoutError, Faraday::RetriableResponse])
-    # methods             - A list of HTTP methods to retry without calling retry_if.  Pass
-    #                       an empty Array to call retry_if for all exceptions.
-    #                       (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
-    # retry_if            - block that will receive the env object and the exception raised
-    #                       and should decide if the code should retry still the action or
-    #                       not independent of the retry count. This would be useful
-    #                       if the exception produced is non-recoverable or if the
-    #                       the HTTP method called is not idempotent.
-    #                       (defaults to return false)
-    # retry_block         - block that is executed after every retry. Request environment, middleware options,
-    #                       current number of retries and the exception is passed to the block as parameters.
-    def initialize(app, options = nil)
-      super(app)
-      @options = Options.from(options)
-      @errmatch = build_exception_matcher(@options.exceptions)
-    end
-
-    def calculate_sleep_amount(retries, env)
-      retry_after     = calculate_retry_after(env)
-      retry_interval  = calculate_retry_interval(retries)
-
-      return if retry_after && retry_after > @options.max_interval
-
-      retry_after && retry_after >= retry_interval ? retry_after : retry_interval
-    end
-
-    def call(env)
-      retries = @options.max
-      request_body = env[:body]
-      begin
-        env[:body] = request_body # after failure env[:body] is set to the response body
-        @app.call(env).tap do |resp|
-          raise Faraday::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
-        end
-      rescue @errmatch => exception
-        if retries > 0 && retry_request?(env, exception)
-          retries -= 1
-          rewind_files(request_body)
-          @options.retry_block.call(env, @options, retries, exception)
-          if (sleep_amount = calculate_sleep_amount(retries + 1, env))
-            sleep sleep_amount
-            retry
-          end
-        end
-
-        if exception.is_a?(Faraday::RetriableResponse)
-          exception.response
-        else
-          raise
-        end
-      end
-    end
-
-    # Private: construct an exception matcher object.
-    #
-    # An exception matcher for the rescue clause can usually be any object that
-    # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
-    def build_exception_matcher(exceptions)
-      matcher = Module.new
-      (class << matcher; self; end).class_eval do
-        define_method(:===) do |error|
-          exceptions.any? do |ex|
-            if ex.is_a? Module
-              error.is_a? ex
-            else
-              error.class.to_s == ex.to_s
-            end
-          end
-        end
-      end
-      matcher
-    end
-
-    private
-
-    def retry_request?(env, exception)
-      @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
-    end
-
-    def rewind_files(body)
-      return unless body.is_a?(Hash)
-      body.each do |_, value|
-        if value.is_a? UploadIO
-          value.rewind
-        end
-      end
-    end
-
-    # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
-    def calculate_retry_after(env)
-      response_headers = env[:response_headers]
-      return unless response_headers
-
-      retry_after_value = env[:response_headers]["Retry-After"]
-
-      # Try to parse date from the header value
-      begin
-        datetime = DateTime.rfc2822(retry_after_value)
-        datetime.to_time - Time.now.utc
-      rescue ArgumentError
-        retry_after_value.to_f
-      end
-    end
-
-    def calculate_retry_interval(retries)
-      retry_index = @options.max - retries
-      current_interval = @options.interval * (@options.backoff_factor ** retry_index)
-      current_interval = [current_interval, @options.max_interval].min
-      random_interval  = rand * @options.interval_randomness.to_f * @options.interval
-
-      current_interval + random_interval
-    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/request/token_authentication.rb

@@ -1,15 +0,0 @@
-module Faraday
-  class Request::TokenAuthentication < Request.load_middleware(:authorization)
-    # Public
-    def self.header(token, options = nil)
-      options ||= {}
-      options[:token] = token
-      super(:Token, options)
-    end
-
-    def initialize(app, token, options = nil)
-      super(app, token, options)
-    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/request/url_encoded.rb

@@ -1,36 +0,0 @@
-module Faraday
-  class Request::UrlEncoded < Faraday::Middleware
-    CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
-
-    class << self
-      attr_accessor :mime_type
-    end
-    self.mime_type = 'application/x-www-form-urlencoded'.freeze
-
-    def call(env)
-      match_content_type(env) do |data|
-        params = Faraday::Utils::ParamsHash[data]
-        env.body = params.to_query(env.params_encoder)
-      end
-      @app.call env
-    end
-
-    def match_content_type(env)
-      if process_request?(env)
-        env.request_headers[CONTENT_TYPE] ||= self.class.mime_type
-        yield(env.body) unless env.body.respond_to?(:to_str)
-      end
-    end
-
-    def process_request?(env)
-      type = request_type(env)
-      env.body and (type.empty? or type == self.class.mime_type)
-    end
-
-    def request_type(env)
-      type = env.request_headers[CONTENT_TYPE].to_s
-      type = type.split(';', 2).first if type.index(';')
-      type
-    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/request.rb

@@ -1,116 +0,0 @@
-module Faraday
-  # Used to setup urls, params, headers, and the request body in a sane manner.
-  #
-  #   @connection.post do |req|
-  #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
-  #     req.headers['b'] = '2' # Header
-  #     req.params['c']  = '3' # GET Param
-  #     req['b']         = '2' # also Header
-  #     req.body = 'abc'
-  #   end
-  #
-  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
-    extend MiddlewareRegistry
-
-    alias_method :http_method, :method
-
-    register_middleware File.expand_path('../request', __FILE__),
-      :url_encoded => [:UrlEncoded, 'url_encoded'],
-      :multipart => [:Multipart, 'multipart'],
-      :retry => [:Retry, 'retry'],
-      :authorization => [:Authorization, 'authorization'],
-      :basic_auth => [:BasicAuthentication, 'basic_authentication'],
-      :token_auth => [:TokenAuthentication, 'token_authentication'],
-      :instrumentation => [:Instrumentation, 'instrumentation']
-
-    def self.create(request_method)
-      new(request_method).tap do |request|
-        yield(request) if block_given?
-      end
-    end
-
-    # Public: Replace params, preserving the existing hash type
-    def params=(hash)
-      if params
-        params.replace hash
-      else
-        super
-      end
-    end
-
-    # Public: Replace request headers, preserving the existing hash type
-    def headers=(hash)
-      if headers
-        headers.replace hash
-      else
-        super
-      end
-    end
-
-    def url(path, params = nil)
-      if path.respond_to? :query
-        if query = path.query
-          path = path.dup
-          path.query = nil
-        end
-      else
-        anchor_index = path.index('#')
-        path = path.slice(0, anchor_index) unless anchor_index.nil?
-        path, query = path.split('?', 2)
-      end
-      self.path = path
-      self.params.merge_query query, options.params_encoder
-      self.params.update(params) if params
-    end
-
-    def [](key)
-      headers[key]
-    end
-
-    def []=(key, value)
-      headers[key] = value
-    end
-
-    def marshal_dump
-      {
-        :method  => method,
-        :body    => body,
-        :headers => headers,
-        :path    => path,
-        :params  => params,
-        :options => options
-      }
-    end
-
-    def marshal_load(serialised)
-      self.method  = serialised[:method]
-      self.body    = serialised[:body]
-      self.headers = serialised[:headers]
-      self.path    = serialised[:path]
-      self.params  = serialised[:params]
-      self.options = serialised[:options]
-    end
-
-    # ENV Keys
-    # :method - a symbolized request method (:get, :post)
-    # :body   - the request body that will eventually be converted to a string.
-    # :url    - URI instance for the current request.
-    # :status           - HTTP response status code
-    # :request_headers  - hash of HTTP Headers to be sent to the server
-    # :response_headers - Hash of HTTP headers from the server
-    # :parallel_manager - sent if the connection is in parallel mode
-    # :request - Hash of options for configuring the request.
-    #   :timeout      - open/read timeout Integer in seconds
-    #   :open_timeout - read timeout Integer in seconds
-    #   :proxy        - Hash of proxy options
-    #     :uri        - Proxy Server URI
-    #     :user       - Proxy server username
-    #     :password   - Proxy server password
-    # :ssl - Hash of options for configuring SSL requests.
-    def to_env(connection)
-      Env.new(method, body, connection.build_exclusive_url(path, params),
-        options, headers, connection.ssl, connection.parallel_manager)
-    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/response/logger.rb

@@ -1,80 +0,0 @@
-require 'forwardable'
-
-module Faraday
-  class Response::Logger < Response::Middleware
-    extend Forwardable
-
-    DEFAULT_OPTIONS = { :headers => true, :bodies => false }
-
-    def initialize(app, logger = nil, options = {})
-      super(app)
-      @logger = logger || begin
-        require 'logger'
-        ::Logger.new($stdout)
-      end
-      @filter = []
-      @options = DEFAULT_OPTIONS.merge(options)
-      yield self if block_given?
-    end
-
-    def_delegators :@logger, :debug, :info, :warn, :error, :fatal
-
-    def call(env)
-      info('request')  { "#{env.method.upcase} #{apply_filters(env.url.to_s)}" }
-      debug('request') { apply_filters( dump_headers env.request_headers ) } if log_headers?(:request)
-      debug('request') { apply_filters( dump_body(env[:body]) ) } if env[:body] && log_body?(:request)
-      super
-    end
-
-    def on_complete(env)
-      info('response')  { "Status #{env.status.to_s}" }
-      debug('response') { apply_filters( dump_headers env.response_headers ) } if log_headers?(:response)
-      debug('response') { apply_filters( dump_body 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)
-      require 'pp' unless body.respond_to?(:pretty_inspect)
-      body.pretty_inspect
-    end
-
-    def log_headers?(type)
-      case @options[:headers]
-      when Hash then @options[:headers][type]
-      else @options[:headers]
-      end
-    end
-
-    def log_body?(type)
-      case @options[:bodies]
-      when Hash then @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
-
-  end
-end

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

@@ -1,25 +0,0 @@
-module Faraday
-  class Response::RaiseError < Response::Middleware
-    ClientErrorStatuses = 400...600
-
-    def on_complete(env)
-      case env[:status]
-      when 404
-        raise Faraday::ResourceNotFound, response_values(env)
-      when 407
-        # mimic the behavior that we get with proxy requests with HTTPS
-        raise Faraday::ConnectionFailed.new(
-                %{407 "Proxy Authentication Required "},
-                response_values(env))
-      when ClientErrorStatuses
-        raise Faraday::ClientError, response_values(env)
-      when nil
-        raise Faraday::NilStatusError, response_values(env)
-      end
-    end
-
-    def response_values(env)
-      {:status => env.status, :headers => env.response_headers, :body => env.body}
-    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/response.rb

@@ -1,97 +0,0 @@
-require 'forwardable'
-
-module Faraday
-  class Response
-    # Used for simple response middleware.
-    class Middleware < Faraday::Middleware
-      def call(env)
-        @app.call(env).on_complete do |environment|
-          on_complete(environment)
-        end
-      end
-
-      # Override this to modify the environment after the response has finished.
-      # Calls the `parse` method if defined
-      def on_complete(env)
-        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
-      end
-    end
-
-    extend Forwardable
-    extend MiddlewareRegistry
-
-    register_middleware File.expand_path('../response', __FILE__),
-      :raise_error => [:RaiseError, 'raise_error'],
-      :logger => [:Logger, 'logger']
-
-    def initialize(env = nil)
-      @env = Env.from(env) if env
-      @on_complete_callbacks = []
-    end
-
-    attr_reader :env
-
-    def_delegators :env, :to_hash
-
-    def status
-      finished? ? env.status : nil
-    end
-
-    def reason_phrase
-      finished? ? env.reason_phrase : nil
-    end
-
-    def headers
-      finished? ? env.response_headers : {}
-    end
-    def_delegator :headers, :[]
-
-    def body
-      finished? ? env.body : nil
-    end
-
-    def finished?
-      !!env
-    end
-
-    def on_complete(&block)
-      if !finished?
-        @on_complete_callbacks << block
-      else
-        yield(env)
-      end
-      return self
-    end
-
-    def finish(env)
-      raise "response already finished" if finished?
-      @env = env.is_a?(Env) ? env : Env.from(env)
-      @on_complete_callbacks.each { |callback| callback.call(@env) }
-      return self
-    end
-
-    def success?
-      finished? && env.success?
-    end
-
-    # because @on_complete_callbacks cannot be marshalled
-    def marshal_dump
-      !finished? ? nil : {
-        :status => @env.status, :body => @env.body,
-        :response_headers => @env.response_headers
-      }
-    end
-
-    def marshal_load(env)
-      @env = Env.from(env)
-    end
-
-    # Expand the env with more properties, without overriding existing ones.
-    # Useful for applying request params after restoring a marshalled Response.
-    def apply_request(request_env)
-      raise "response didn't finish yet" unless finished?
-      @env = Env.from(request_env).update(@env)
-      return self
-    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/upload_io.rb

@@ -1,67 +0,0 @@
-begin
-  require 'composite_io'
-  require 'parts'
-  require 'stringio'
-rescue LoadError
-  $stderr.puts "Install the multipart-post gem."
-  raise
-end
-
-module Faraday
-  # Similar but not compatible with ::CompositeReadIO provided by multipart-post.
-  class CompositeReadIO
-    def initialize(*parts)
-      @parts = parts.flatten
-      @ios = @parts.map { |part| part.to_io }
-      @index = 0
-    end
-
-    def length
-      @parts.inject(0) { |sum, part| sum + part.length }
-    end
-
-    def rewind
-      @ios.each { |io| io.rewind }
-      @index = 0
-    end
-
-    # Read from IOs in order until `length` bytes have been received.
-    def read(length = nil, outbuf = nil)
-      got_result = false
-      outbuf = outbuf ? outbuf.replace("") : ""
-
-      while io = current_io
-        if result = io.read(length)
-          got_result ||= !result.nil?
-          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
-          outbuf << result
-          length -= result.length if length
-          break if length == 0
-        end
-        advance_io
-      end
-      (!got_result && length) ? nil : outbuf
-    end
-
-    def close
-      @ios.each { |io| io.close }
-    end
-
-    def ensure_open_and_readable
-      # Rubinius compatibility
-    end
-
-    private
-
-    def current_io
-      @ios[@index]
-    end
-
-    def advance_io
-      @index += 1
-    end
-  end
-
-  UploadIO = ::UploadIO
-  Parts = ::Parts
-end