faraday 0.17.3 → 2.7.4

data/lib/faraday/request/json.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Request
+    # Request middleware that encodes the body as JSON.
+    #
+    # Processes only requests with matching Content-type or those without a type.
+    # If a request doesn't have a type but has a body, it sets the Content-type
+    # to JSON MIME-type.
+    #
+    # Doesn't try to encode bodies that already are in string form.
+    class Json < Middleware
+      MIME_TYPE = 'application/json'
+      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
+
+      def on_request(env)
+        match_content_type(env) do |data|
+          env[:body] = encode(data)
+        end
+      end
+
+      private
+
+      def encode(data)
+        ::JSON.generate(data)
+      end
+
+      def match_content_type(env)
+        return unless process_request?(env)
+
+        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
+        yield env[:body] unless env[:body].respond_to?(:to_str)
+      end
+
+      def process_request?(env)
+        type = request_type(env)
+        body?(env) && (type.empty? || type.match?(MIME_TYPE_REGEX))
+      end
+
+      def body?(env)
+        (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
+      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
+end
+
+Faraday::Request.register_middleware(json: Faraday::Request::Json)

data/lib/faraday/request/url_encoded.rb

@@ -1,36 +1,60 @@
+# 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
+      unless defined?(::Faraday::Request::UrlEncoded::CONTENT_TYPE)
+        CONTENT_TYPE = 'Content-Type'
+      end
 
-    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)
+        return if env.body.respond_to?(:to_str) || env.body.respond_to?(:read)
+
+        yield(env.body)
       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
+
+Faraday::Request.register_middleware(url_encoded: Faraday::Request::UrlEncoded)

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,38 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
-  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
-    extend MiddlewareRegistry
+  # @!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 [String] 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
 
-    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']
+    extend MiddlewareRegistry
 
+    # @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
@@ -36,7 +52,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 +63,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 +84,53 @@ 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.http_method = serialised[:http_method]
+      self.body = serialised[:body]
       self.headers = serialised[:headers]
-      self.path    = serialised[:path]
-      self.params  = serialised[:params]
+      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
 
+require 'faraday/request/authorization'
+require 'faraday/request/instrumentation'
+require 'faraday/request/json'
+require 'faraday/request/url_encoded'

data/lib/faraday/response/json.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Faraday
+  class Response
+    # Parse response bodies as JSON.
+    class Json < Middleware
+      def initialize(app = nil, parser_options: nil, content_type: /\bjson$/, preserve_raw: false)
+        super(app)
+        @parser_options = parser_options
+        @content_types = Array(content_type)
+        @preserve_raw = preserve_raw
+      end
+
+      def on_complete(env)
+        process_response(env) if parse_response?(env)
+      end
+
+      private
+
+      def process_response(env)
+        env[:raw_body] = env[:body] if @preserve_raw
+        env[:body] = parse(env[:body])
+      rescue StandardError, SyntaxError => e
+        raise Faraday::ParsingError.new(e, env[:response])
+      end
+
+      def parse(body)
+        ::JSON.parse(body, @parser_options || {}) unless body.strip.empty?
+      end
+
+      def parse_response?(env)
+        process_response_type?(env) &&
+          env[:body].respond_to?(:to_str)
+      end
+
+      def process_response_type?(env)
+        type = response_type(env)
+        @content_types.empty? || @content_types.any? do |pattern|
+          pattern.is_a?(Regexp) ? type.match?(pattern) : type == pattern
+        end
+      end
+
+      def response_type(env)
+        type = env[:response_headers][CONTENT_TYPE].to_s
+        type = type.split(';', 2).first if type.index(';')
+        type
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(json: Faraday::Response::Json)

data/lib/faraday/response/logger.rb

@@ -1,80 +1,37 @@
+# frozen_string_literal: true
+
 require 'forwardable'
+require 'logger'
+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)
+  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 ||= ::Logger.new($stdout)
+        formatter_class = options.delete(:formatter) || Logging::Formatter
+        @formatter = formatter_class.new(logger: logger, options: options)
+        yield @formatter if block_given?
       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)
+      def call(env)
+        @formatter.request(env)
+        super
       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]
+      def on_complete(env)
+        @formatter.response(env)
       end
-    end
 
-    def log_body?(type)
-      case @options[:bodies]
-      when Hash then @options[:bodies][type]
-      else @options[:bodies]
+      def on_error(exc)
+        @formatter.exception(exc) if @formatter.respond_to?(:exception)
       end
     end
-
-    def apply_filters(output)
-      @filter.each do |pattern, replacement|
-        output = output.to_s.gsub(pattern, replacement)
-      end
-      output
-    end
-
   end
 end
+
+Faraday::Response.register_middleware(logger: Faraday::Response::Logger)

data/lib/faraday/response/raise_error.rb

@@ -1,25 +1,64 @@
+# 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
+
+      def response_values(env)
+        {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body,
+          request: {
+            method: env.method,
+            url: env.url,
+            url_path: env.url.path,
+            params: query_params(env),
+            headers: env.request_headers,
+            body: env.request_body
+          }
+        }
       end
-    end
 
-    def response_values(env)
-      {:status => env.status, :headers => env.response_headers, :body => env.body}
+      def query_params(env)
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env.params_encoder.decode(env.url.query)
+      end
     end
   end
 end
+
+Faraday::Response.register_middleware(raise_error: Faraday::Response::RaiseError)

data/lib/faraday/response.rb

@@ -1,29 +1,13 @@
+# 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
-      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 = []
@@ -31,8 +15,6 @@ module Faraday
 
     attr_reader :env
 
-    def_delegators :env, :to_hash
-
     def status
       finished? ? env.status : nil
     end
@@ -44,6 +26,7 @@ module Faraday
     def headers
       finished? ? env.response_headers : {}
     end
+
     def_delegator :headers, :[]
 
     def body
@@ -55,31 +38,37 @@ module Faraday
     end
 
     def on_complete(&block)
-      if !finished?
-        @on_complete_callbacks << block
-      else
+      if finished?
         yield(env)
+      else
+        @on_complete_callbacks << block
       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,
+        url: env.url
+      }
+    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 +79,13 @@ 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
+
+require 'faraday/response/json'
+require 'faraday/response/logger'
+require 'faraday/response/raise_error'