faraday 0.11.0 → 1.4.3

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 "#{env.method} #{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('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,21 +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::Error::ResourceNotFound, response_values(env)
-      when 407
-        # mimic the behavior that we get with proxy requests with HTTPS
-        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-      when ClientErrorStatuses
-        raise Faraday::Error::ClientError, 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
@@ -54,32 +52,37 @@ module Faraday
       !!env
     end
 
-    def on_complete
-      if not finished?
-        @on_complete_callbacks << Proc.new
+    def on_complete(&block)
+      if !finished?
+        @on_complete_callbacks << block
       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