faraday 0.16.0 → 0.17.4

data/lib/faraday/request/url_encoded.rb

@@ -1,54 +1,36 @@
-# frozen_string_literal: true
-
 module Faraday
-  class Request
-    # Middleware for supporting urlencoded requests.
-    class UrlEncoded < Faraday::Middleware
-      CONTENT_TYPE = 'Content-Type' unless defined? CONTENT_TYPE
+  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'
+    class << self
+      attr_accessor :mime_type
+    end
+    self.mime_type = 'application/x-www-form-urlencoded'.freeze
 
-      # 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
+    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
 
-      # @param env [Faraday::Env]
-      # @yield [request_body] Body of the request
-      def match_content_type(env)
-        return unless process_request?(env)
-
+    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
 
-      # @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 process_request?(env)
+      type = request_type(env)
+      env.body and (type.empty? or type == self.class.mime_type)
+    end
 
-      # @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
+    def request_type(env)
+      type = env.request_headers[CONTENT_TYPE].to_s
+      type = type.split(';', 2).first if type.index(';')
+      type
     end
   end
 end

data/lib/faraday/request.rb

@@ -1,9 +1,6 @@
-# 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
@@ -12,53 +9,25 @@ 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)
-    # rubocop:enable Style/StructInheritance
-
     extend MiddlewareRegistry
 
-    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']
+    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']
 
-    # @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
 
-    # Replace params, preserving the existing hash type.
-    #
-    # @param hash [Hash] new params
+    # Public: Replace params, preserving the existing hash type
     def params=(hash)
       if params
         params.replace hash
@@ -67,9 +36,7 @@ module Faraday
       end
     end
 
-    # Replace request headers, preserving the existing hash type.
-    #
-    # @param hash [Hash] new headers
+    # Public: Replace request headers, preserving the existing hash type
     def headers=(hash)
       if headers
         headers.replace hash
@@ -78,14 +45,9 @@ 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
@@ -99,35 +61,25 @@ 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]
@@ -137,10 +89,26 @@ module Faraday
       self.options = serialised[:options]
     end
 
-    # @return [Env] the Env for this Request
+    # 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)
+        options, headers, connection.ssl, connection.parallel_manager)
     end
   end
 end
+

data/lib/faraday/response/logger.rb

@@ -1,33 +1,80 @@
-# frozen_string_literal: true
-
 require 'forwardable'
-require 'faraday/logging/formatter'
 
 module Faraday
-  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?
+  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 call(env)
-        @formatter.request(env)
-        super
+    def log_body?(type)
+      case @options[:bodies]
+      when Hash then @options[:bodies][type]
+      else @options[:bodies]
       end
+    end
 
-      def on_complete(env)
-        @formatter.response(env)
+    def apply_filters(output)
+      @filter.each do |pattern, replacement|
+        output = output.to_s.gsub(pattern, replacement)
       end
+      output
     end
+
   end
 end

data/lib/faraday/response/raise_error.rb

@@ -1,43 +1,25 @@
-# frozen_string_literal: true
-
 module Faraday
-  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
+  class Response::RaiseError < Response::Middleware
+    ClientErrorStatuses = 400...600
 
-      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
+    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
+    def response_values(env)
+      {:status => env.status, :headers => env.response_headers, :body => env.body}
     end
   end
 end

data/lib/faraday/response.rb

@@ -1,9 +1,6 @@
-# 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
@@ -23,9 +20,9 @@ module Faraday
     extend Forwardable
     extend MiddlewareRegistry
 
-    register_middleware File.expand_path('response', __dir__),
-                        raise_error: [:RaiseError, 'raise_error'],
-                        logger: [:Logger, 'logger']
+    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
@@ -34,6 +31,8 @@ module Faraday
 
     attr_reader :env
 
+    def_delegators :env, :to_hash
+
     def status
       finished? ? env.status : nil
     end
@@ -61,31 +60,26 @@ module Faraday
       else
         yield(env)
       end
-      self
+      return 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) }
-      self
+      return 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? ? to_hash : nil
+      !finished? ? nil : {
+        :status => @env.status, :body => @env.body,
+        :response_headers => @env.response_headers
+      }
     end
 
     def marshal_load(env)
@@ -96,9 +90,8 @@ 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)
-      self
+      return self
     end
   end
 end

data/lib/faraday/upload_io.rb

@@ -0,0 +1,67 @@
+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