faraday 0.17.6 → 1.0.0.pre.rc1

data/lib/faraday/request/url_encoded.rb

@@ -1,36 +1,54 @@
+# frozen_string_literal: true
+
 module Faraday
-  class Request::UrlEncoded < Faraday::Middleware
-    CONTENT_TYPE = 'Content-Type'.freeze unless defined? CONTENT_TYPE
+  class Request
+    # Middleware for supporting urlencoded requests.
+    class UrlEncoded < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type' unless defined? CONTENT_TYPE
 
-    class << self
-      attr_accessor :mime_type
-    end
-    self.mime_type = 'application/x-www-form-urlencoded'.freeze
+      class << self
+        attr_accessor :mime_type
+      end
+      self.mime_type = 'application/x-www-form-urlencoded'
 
-    def call(env)
-      match_content_type(env) do |data|
-        params = Faraday::Utils::ParamsHash[data]
-        env.body = params.to_query(env.params_encoder)
+      # Encodes as "application/x-www-form-urlencoded" if not already encoded or
+      # of another type.
+      #
+      # @param env [Faraday::Env]
+      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
-      @app.call env
-    end
 
-    def match_content_type(env)
-      if process_request?(env)
+      # @param env [Faraday::Env]
+      # @yield [request_body] Body of the request
+      def match_content_type(env)
+        return unless 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
+      # @param env [Faraday::Env]
+      #
+      # @return [Boolean] True if the request has a body and its Content-Type is
+      #                   urlencoded.
+      def process_request?(env)
+        type = request_type(env)
+        env.body && (type.empty? || (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
+      # @param env [Faraday::Env]
+      #
+      # @return [String]
+      def request_type(env)
+        type = env.request_headers[CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
     end
   end
 end

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,27 +12,53 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
+  # @!attribute 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(:method, :path, :params, :headers, :body, :options)
-    extend MiddlewareRegistry
+    # rubocop:enable Style/StructInheritance
 
-    alias_method :http_method, :method
+    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'],
+                        multipart: [:Multipart, 'multipart'],
+                        retry: [:Retry, 'retry'],
+                        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
+    # Replace params, preserving the existing hash type.
+    #
+    # @param hash [Hash] new params
     def params=(hash)
       if params
         params.replace hash
@@ -38,7 +67,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
@@ -47,9 +78,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
@@ -63,25 +99,35 @@ 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
+        method: 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]
@@ -91,26 +137,10 @@ module Faraday
       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)
+              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,43 @@
+# 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)
+        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 }
+      end
     end
   end
 end

data/lib/faraday/response.rb

@@ -1,6 +1,9 @@
+# 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
@@ -20,9 +23,9 @@ module Faraday
     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 +34,6 @@ module Faraday
 
     attr_reader :env
 
-    def_delegators :env, :to_hash
-
     def status
       finished? ? env.status : nil
     end
@@ -54,32 +55,37 @@ module Faraday
       !!env
     end
 
-    def on_complete(&block)
+    def on_complete
       if !finished?
-        @on_complete_callbacks << block
+        @on_complete_callbacks << Proc.new
       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 +96,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/upload_io.rb

@@ -1,55 +1,61 @@
-begin
-  require 'multipart/post'
-  require 'stringio'
-rescue LoadError
-  begin
-    require 'composite_io'
-    require 'parts'
-    require 'stringio'
-  rescue LoadError
-    $stderr.puts "Install the multipart-post gem."
-    raise
-  end
-end
+# frozen_string_literal: true
+
+require 'stringio'
+
+# multipart-post gem
+require 'composite_io'
+require 'parts'
 
 module Faraday
-  # Similar but not compatible with ::CompositeReadIO provided by multipart-post.
+  # Similar to, but not compatible with CompositeReadIO provided by the
+  # multipart-post gem.
+  # https://github.com/nicksieger/multipart-post/blob/master/lib/composite_io.rb
   class CompositeReadIO
     def initialize(*parts)
       @parts = parts.flatten
-      @ios = @parts.map { |part| part.to_io }
+      @ios = @parts.map(&:to_io)
       @index = 0
     end
 
+    # @return [Integer] sum of the lengths of all the parts
     def length
       @parts.inject(0) { |sum, part| sum + part.length }
     end
 
+    # Rewind each of the IOs and reset the index to 0.
+    #
+    # @return [void]
     def rewind
-      @ios.each { |io| io.rewind }
+      @ios.each(&:rewind)
       @index = 0
     end
 
     # Read from IOs in order until `length` bytes have been received.
+    #
+    # @param length [Integer, nil]
+    # @param outbuf [String, nil]
     def read(length = nil, outbuf = nil)
       got_result = false
-      outbuf = outbuf ? outbuf.replace("") : ""
+      outbuf = outbuf ? (+outbuf).replace('') : +''
 
-      while io = current_io
-        if result = io.read(length)
+      while (io = current_io)
+        if (result = io.read(length))
           got_result ||= !result.nil?
-          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
+          result.force_encoding('BINARY') if result.respond_to?(:force_encoding)
           outbuf << result
           length -= result.length if length
-          break if length == 0
+          break if length&.zero?
         end
         advance_io
       end
-      (!got_result && length) ? nil : outbuf
+      !got_result && length ? nil : outbuf
     end
 
+    # Close each of the IOs.
+    #
+    # @return [void]
     def close
-      @ios.each { |io| io.close }
+      @ios.each(&:close)
     end
 
     def ensure_open_and_readable
@@ -67,11 +73,6 @@ module Faraday
     end
   end
 
-  if defined?(::Multipart::Post::UploadIO)
-    UploadIO = ::Multipart::Post::UploadIO
-    Parts = ::Multipart::Post::Parts
-  else
-    UploadIO = ::UploadIO
-    Parts = ::Parts
-  end
+  UploadIO = ::UploadIO
+  Parts = ::Parts
 end