faraday 0.17.3 → 1.9.3

data/lib/faraday/request.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module Faraday
-  # Used to setup urls, params, headers, and the request body in a sane manner.
+  # Used to setup URLs, params, headers, and the request body in a sane manner.
   #
+  # @example
   #   @connection.post do |req|
   #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
   #     req.headers['b'] = '2' # Header
@@ -9,25 +12,61 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
-  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
+  # @!attribute http_method
+  #   @return [Symbol] the HTTP method of the Request
+  # @!attribute path
+  #   @return [URI, String] the path
+  # @!attribute params
+  #   @return [Hash] query parameters
+  # @!attribute headers
+  #   @return [Faraday::Utils::Headers] headers
+  # @!attribute body
+  #   @return [Hash] body
+  # @!attribute options
+  #   @return [RequestOptions] options
+  #
+  # rubocop:disable Style/StructInheritance
+  class Request < Struct.new(
+    :http_method, :path, :params, :headers, :body, :options
+  )
+    # rubocop:enable Style/StructInheritance
+
     extend MiddlewareRegistry
 
-    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']
+    register_middleware File.expand_path('request', __dir__),
+                        url_encoded: [:UrlEncoded, 'url_encoded'],
+                        authorization: [:Authorization, 'authorization'],
+                        basic_auth: [
+                          :BasicAuthentication,
+                          'basic_authentication'
+                        ],
+                        token_auth: [
+                          :TokenAuthentication,
+                          'token_authentication'
+                        ],
+                        instrumentation: [:Instrumentation, 'instrumentation']
 
+    # @param request_method [String]
+    # @yield [request] for block customization, if block given
+    # @yieldparam request [Request]
+    # @return [Request]
     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 method
+      warn <<~TEXT
+        WARNING: `Faraday::Request##{__method__}` is deprecated; use `#http_method` instead. It will be removed in or after version 2.0.
+        `Faraday::Request##{__method__}` called from #{caller_locations(1..1).first}
+      TEXT
+      http_method
+    end
+
+    # Replace params, preserving the existing hash type.
+    #
+    # @param hash [Hash] new params
     def params=(hash)
       if params
         params.replace hash
@@ -36,7 +75,9 @@ module Faraday
       end
     end
 
-    # Public: Replace request headers, preserving the existing hash type
+    # Replace request headers, preserving the existing hash type.
+    #
+    # @param hash [Hash] new headers
     def headers=(hash)
       if headers
         headers.replace hash
@@ -45,9 +86,14 @@ module Faraday
       end
     end
 
+    # Update path and params.
+    #
+    # @param path [URI, String]
+    # @param params [Hash, nil]
+    # @return [void]
     def url(path, params = nil)
       if path.respond_to? :query
-        if query = path.query
+        if (query = path.query)
           path = path.dup
           path.query = nil
         end
@@ -61,54 +107,48 @@ module Faraday
       self.params.update(params) if params
     end
 
+    # @param key [Object] key to look up in headers
+    # @return [Object] value of the given header name
     def [](key)
       headers[key]
     end
 
+    # @param key [Object] key of header to write
+    # @param value [Object] value of header
     def []=(key, value)
       headers[key] = value
     end
 
+    # Marshal serialization support.
+    #
+    # @return [Hash] the hash ready to be serialized in Marshal.
     def marshal_dump
       {
-        :method  => method,
-        :body    => body,
-        :headers => headers,
-        :path    => path,
-        :params  => params,
-        :options => options
+        http_method: http_method,
+        body: body,
+        headers: headers,
+        path: path,
+        params: params,
+        options: options
       }
     end
 
+    # Marshal serialization support.
+    # Restores the instance variables according to the +serialised+.
+    # @param serialised [Hash] the serialised object.
     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]
+      self.http_method = serialised[:http_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.
+    # @return [Env] the Env for this Request
     def to_env(connection)
-      Env.new(method, body, connection.build_exclusive_url(path, params),
-        options, headers, connection.ssl, connection.parallel_manager)
+      Env.new(http_method, body, connection.build_exclusive_url(path, params),
+              options, headers, connection.ssl, connection.parallel_manager)
     end
   end
 end
-

data/lib/faraday/response/logger.rb

@@ -1,80 +1,33 @@
+# frozen_string_literal: true
+
 require 'forwardable'
+require 'faraday/logging/formatter'
 
 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]
+  class Response
+    # Logger is a middleware that logs internal events in the HTTP request
+    # lifecycle to a given Logger object. By default, this logs to STDOUT. See
+    # Faraday::Logging::Formatter to see specifically what is logged.
+    class Logger < Middleware
+      def initialize(app, logger = nil, options = {})
+        super(app)
+        logger ||= begin
+          require 'logger'
+          ::Logger.new($stdout)
+        end
+        formatter_class = options.delete(:formatter) || Logging::Formatter
+        @formatter = formatter_class.new(logger: logger, options: options)
+        yield @formatter if block_given?
       end
-    end
 
-    def log_body?(type)
-      case @options[:bodies]
-      when Hash then @options[:bodies][type]
-      else @options[:bodies]
+      def call(env)
+        @formatter.request(env)
+        super
       end
-    end
 
-    def apply_filters(output)
-      @filter.each do |pattern, replacement|
-        output = output.to_s.gsub(pattern, replacement)
+      def on_complete(env)
+        @formatter.response(env)
       end
-      output
     end
-
   end
 end

data/lib/faraday/response/raise_error.rb

@@ -1,25 +1,56 @@
+# frozen_string_literal: true
+
 module Faraday
-  class Response::RaiseError < Response::Middleware
-    ClientErrorStatuses = 400...600
+  class Response
+    # RaiseError is a Faraday middleware that raises exceptions on common HTTP
+    # client or server error responses.
+    class RaiseError < Middleware
+      # rubocop:disable Naming/ConstantName
+      ClientErrorStatuses = (400...500).freeze
+      ServerErrorStatuses = (500...600).freeze
+      # rubocop:enable Naming/ConstantName
 
-    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)
+      def on_complete(env)
+        case env[:status]
+        when 400
+          raise Faraday::BadRequestError, response_values(env)
+        when 401
+          raise Faraday::UnauthorizedError, response_values(env)
+        when 403
+          raise Faraday::ForbiddenError, response_values(env)
+        when 404
+          raise Faraday::ResourceNotFound, response_values(env)
+        when 407
+          # mimic the behavior that we get with proxy requests with HTTPS
+          msg = %(407 "Proxy Authentication Required")
+          raise Faraday::ProxyAuthError.new(msg, response_values(env))
+        when 409
+          raise Faraday::ConflictError, response_values(env)
+        when 422
+          raise Faraday::UnprocessableEntityError, response_values(env)
+        when ClientErrorStatuses
+          raise Faraday::ClientError, response_values(env)
+        when ServerErrorStatuses
+          raise Faraday::ServerError, response_values(env)
+        when nil
+          raise Faraday::NilStatusError, response_values(env)
+        end
       end
-    end
 
-    def response_values(env)
-      {:status => env.status, :headers => env.response_headers, :body => env.body}
+      def response_values(env)
+        {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body,
+          request: {
+            method: env.method,
+            url_path: env.url.path,
+            params: env.params,
+            headers: env.request_headers,
+            body: env.request_body
+          }
+        }
+      end
     end
   end
 end

data/lib/faraday/response.rb

@@ -1,28 +1,28 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Faraday
+  # Response represents an HTTP response from making an HTTP request.
   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
+      # `parse` method can be defined as private, public and protected
       def on_complete(env)
-        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
+        return unless respond_to?(:parse, true) && env.parse_body?
+
+        env.body = parse(env.body)
       end
     end
 
     extend Forwardable
     extend MiddlewareRegistry
 
-    register_middleware File.expand_path('../response', __FILE__),
-      :raise_error => [:RaiseError, 'raise_error'],
-      :logger => [:Logger, 'logger']
+    register_middleware File.expand_path('response', __dir__),
+                        raise_error: [:RaiseError, 'raise_error'],
+                        logger: [:Logger, 'logger']
 
     def initialize(env = nil)
       @env = Env.from(env) if env
@@ -31,8 +31,6 @@ module Faraday
 
     attr_reader :env
 
-    def_delegators :env, :to_hash
-
     def status
       finished? ? env.status : nil
     end
@@ -60,26 +58,31 @@ module Faraday
       else
         yield(env)
       end
-      return self
+      self
     end
 
     def finish(env)
-      raise "response already finished" if finished?
+      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
+      self
     end
 
     def success?
       finished? && env.success?
     end
 
+    def to_hash
+      {
+        status: env.status, body: env.body,
+        response_headers: env.response_headers
+      }
+    end
+
     # because @on_complete_callbacks cannot be marshalled
     def marshal_dump
-      !finished? ? nil : {
-        :status => @env.status, :body => @env.body,
-        :response_headers => @env.response_headers
-      }
+      finished? ? to_hash : nil
     end
 
     def marshal_load(env)
@@ -90,8 +93,9 @@ module Faraday
     # 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
+      self
     end
   end
 end

data/lib/faraday/utils/headers.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Utils
+    # A case-insensitive Hash that preserves the original case of a header
+    # when set.
+    #
+    # 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 = {}
+        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(&:capitalize!) # => %w(User Agent)
+                     .join('-') # => "User-Agent"
+                end
+        keymap_mutex.synchronize { map[key] = value }
+      end
+      KeyMap[:etag] = 'ETag'
+
+      def [](key)
+        key = KeyMap[key]
+        super(key) || super(@names[key.downcase])
+      end
+
+      def []=(key, val)
+        key = KeyMap[key]
+        key = (@names[key.downcase] ||= key)
+        # join multiple values with a comma
+        val = val.to_ary.join(', ') if val.respond_to?(:to_ary)
+        super(key, val)
+      end
+
+      def fetch(key, *args, &block)
+        key = KeyMap[key]
+        key = @names.fetch(key.downcase, key)
+        super(key, *args, &block)
+      end
+
+      def delete(key)
+        key = KeyMap[key]
+        key = @names[key.downcase]
+        return unless key
+
+        @names.delete key.downcase
+        super(key)
+      end
+
+      def include?(key)
+        @names.include? key.downcase
+      end
+
+      alias has_key? include?
+      alias member? include?
+      alias key? include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+
+      alias update merge!
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        @names.clear
+        update other
+        self
+      end
+
+      def to_hash
+        {}.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.start_with?('HTTP/') } || 0
+        last_response = headers.slice(start_index, headers.size)
+
+        last_response
+          .tap { |a| a.shift if a.first.start_with?('HTTP/') }
+          .map { |h| h.split(/:\s*/, 2) } # split key and value
+          .reject { |p| p[0].nil? } # ignore blank lines
+          .each { |key, value| add_parsed(key, value) }
+      end
+
+      protected
+
+      attr_reader :names
+
+      private
+
+      # Join multiple values with a comma.
+      def add_parsed(key, value)
+        self[key] ? self[key] << ', ' << value : self[key] = value
+      end
+    end
+  end
+end

data/lib/faraday/utils/params_hash.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Faraday
+  module Utils
+    # A 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 has_key? include?
+      alias member? include?
+      alias key? include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias merge! update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query, encoder = nil)
+        return self unless query && !query.empty?
+
+        update((encoder || Utils.default_params_encoder).decode(query))
+      end
+
+      def to_query(encoder = nil)
+        (encoder || Utils.default_params_encoder).encode(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+  end
+end