faraday 0.16.2 → 0.17.0

data/lib/faraday/logging/formatter.rb

@@ -1,92 +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 }.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)
-        info('request') do
-          "#{env.method.upcase} #{apply_filters(env.url.to_s)}"
-        end
-        if log_headers?(:request)
-          debug('request') { apply_filters(dump_headers(env.request_headers)) }
-        end
-        return unless env[:body] && log_body?(:request)
-
-        debug('request') { apply_filters(dump_body(env[:body])) }
-      end
-
-      def response(env)
-        info('response') { "Status #{env.status}" }
-        if log_headers?(:response)
-          debug('response') do
-            apply_filters(dump_headers(env.response_headers))
-          end
-        end
-        return unless env[:body] && log_body?(:response)
-
-        debug('response') { apply_filters(dump_body(env[:body])) }
-      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
-    end
-  end
-end

data/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

data/lib/faraday/options/connection_options.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # ConnectionOptions contains the configurable properties for a Faraday
-  # connection object.
-  class ConnectionOptions < Options.new(:request, :proxy, :ssl, :builder, :url,
-                                        :parallel_manager, :params, :headers,
-                                        :builder_class)
-
-    options request: RequestOptions, ssl: SSLOptions
-
-    memoized(:request) { self.class.options_for(:request).new }
-
-    memoized(:ssl) { self.class.options_for(:ssl).new }
-
-    memoized(:builder_class) { RackBuilder }
-
-    def new_builder(block)
-      builder_class.new(&block)
-    end
-  end
-end

data/lib/faraday/options/env.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # @!attribute method
-  #   @return [Symbol] HTTP method (`:get`, `:post`)
-  #
-  # @!attribute body
-  #   @return [String] The request body that will eventually be converted to a
-  #   string.
-  #
-  # @!attribute url
-  #   @return [URI] URI instance for the current request.
-  #
-  # @!attribute request
-  #   @return [Hash] options for configuring the request.
-  #   Options for configuring the request.
-  #
-  #   - `:timeout`  open/read timeout Integer in seconds
-  #   - `:open_timeout` - read timeout Integer in seconds
-  #   - `:on_data`      - Proc for streaming
-  #   - `:proxy`        - Hash of proxy options
-  #       - `:uri`        - Proxy Server URI
-  #       - `:user`       - Proxy server username
-  #       - `:password`   - Proxy server password
-  #
-  # @!attribute request_headers
-  #   @return [Hash] HTTP Headers to be sent to the server.
-  #
-  # @!attribute ssl
-  #   @return [Hash] options for configuring SSL requests
-  #
-  # @!attribute parallel_manager
-  #   @return [Object] sent if the connection is in parallel mode
-  #
-  # @!attribute params
-  #   @return [Hash]
-  #
-  # @!attribute response
-  #   @return [Response]
-  #
-  # @!attribute response_headers
-  #   @return [Hash] HTTP headers from the server
-  #
-  # @!attribute status
-  #   @return [Integer] HTTP response status code
-  #
-  # @!attribute reason_phrase
-  #   @return [String]
-  class Env < Options.new(:method, :request_body, :url, :request,
-                          :request_headers, :ssl, :parallel_manager, :params,
-                          :response, :response_headers, :status,
-                          :reason_phrase, :response_body)
-
-    # rubocop:disable Naming/ConstantName
-    ContentLength = 'Content-Length'
-    StatusesWithoutBody = Set.new [204, 304]
-    SuccessfulStatuses = (200..299).freeze
-    # rubocop:enable Naming/ConstantName
-
-    # A Set of HTTP verbs that typically send a body.  If no body is set for
-    # these requests, the Content-Length header is set to 0.
-    MethodsWithBodies = Set.new(Faraday::METHODS_WITH_BODY.map(&:to_sym))
-
-    options request: RequestOptions,
-            request_headers: Utils::Headers, response_headers: Utils::Headers
-
-    extend Forwardable
-
-    def_delegators :request, :params_encoder
-
-    # Build a new Env from given value. Respects and updates `custom_members`.
-    #
-    # @param value [Object] a value fitting Option.from(v).
-    # @return [Env] from given value
-    def self.from(value)
-      env = super(value)
-      if value.respond_to?(:custom_members)
-        env.custom_members.update(value.custom_members)
-      end
-      env
-    end
-
-    # @param key [Object]
-    def [](key)
-      return self[current_body] if key == :body
-
-      if in_member_set?(key)
-        super(key)
-      else
-        custom_members[key]
-      end
-    end
-
-    # @param key [Object]
-    # @param value [Object]
-    def []=(key, value)
-      if key == :body
-        super(current_body, value)
-        return
-      end
-
-      if in_member_set?(key)
-        super(key, value)
-      else
-        custom_members[key] = value
-      end
-    end
-
-    def current_body
-      !!status ? :response_body : :request_body
-    end
-
-    def body
-      self[:body]
-    end
-
-    def body=(value)
-      self[:body] = value
-    end
-
-    # @return [Boolean] true if status is in the set of {SuccessfulStatuses}.
-    def success?
-      SuccessfulStatuses.include?(status)
-    end
-
-    # @return [Boolean] true if there's no body yet, and the method is in the
-    # set of {MethodsWithBodies}.
-    def needs_body?
-      !body && MethodsWithBodies.include?(method)
-    end
-
-    # Sets content length to zero and the body to the empty string.
-    def clear_body
-      request_headers[ContentLength] = '0'
-      self.body = ''
-    end
-
-    # @return [Boolean] true if the status isn't in the set of
-    # {StatusesWithoutBody}.
-    def parse_body?
-      !StatusesWithoutBody.include?(status)
-    end
-
-    # @return [Boolean] true if there is a parallel_manager
-    def parallel?
-      !!parallel_manager
-    end
-
-    def inspect
-      attrs = [nil]
-      members.each do |mem|
-        if (value = send(mem))
-          attrs << "@#{mem}=#{value.inspect}"
-        end
-      end
-      attrs << "@custom=#{custom_members.inspect}" unless custom_members.empty?
-      %(#<#{self.class}#{attrs.join(' ')}>)
-    end
-
-    # @private
-    def custom_members
-      @custom_members ||= {}
-    end
-
-    # @private
-    if members.first.is_a?(Symbol)
-      def in_member_set?(key)
-        self.class.member_set.include?(key.to_sym)
-      end
-    else
-      def in_member_set?(key)
-        self.class.member_set.include?(key.to_s)
-      end
-    end
-
-    # @private
-    def self.member_set
-      @member_set ||= Set.new(members)
-    end
-  end
-end

data/lib/faraday/options/proxy_options.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Faraday
-  # ProxyOptions contains the configurable properties for the proxy
-  # configuration used when making an HTTP request.
-  class ProxyOptions < Options.new(:uri, :user, :password)
-    extend Forwardable
-    def_delegators :uri, :scheme, :scheme=, :host, :host=, :port, :port=,
-                   :path, :path=
-
-    def self.from(value)
-      case value
-      when String
-        value = { uri: Utils.URI(value) }
-      when URI
-        value = { uri: value }
-      when Hash, Options
-        if (uri = value.delete(:uri))
-          value[:uri] = Utils.URI(uri)
-        end
-      end
-      super(value)
-    end
-
-    memoized(:user) { uri&.user && Utils.unescape(uri.user) }
-    memoized(:password) { uri&.password && Utils.unescape(uri.password) }
-  end
-end