faraday 0.16.2 → 0.17.0

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
@@ -55,37 +54,32 @@ module Faraday
       !!env
     end
 
-    def on_complete(&block)
-      if !finished?
-        @on_complete_callbacks << block
+    def on_complete
+      if not finished?
+        @on_complete_callbacks << Proc.new
       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/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,21 @@
-# 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::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)
       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/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

data/lib/faraday/utils.rb

@@ -1,12 +1,193 @@
-# frozen_string_literal: true
-
-require 'faraday/utils/headers'
-require 'faraday/utils/params_hash'
+require 'thread'
 
 module Faraday
-  # Utils contains various static helper methods.
   module Utils
-    module_function
+    extend self
+
+    # 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 = {}
+        self.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 { |w| w.capitalize! }.   # => %w(User Agent)
+            join('-')                     # => "User-Agent"
+        end
+        keymap_mutex.synchronize { map[key] = value }
+      end
+      KeyMap[:etag] = "ETag"
+
+      def [](k)
+        k = KeyMap[k]
+        super(k) || super(@names[k.downcase])
+      end
+
+      def []=(k, v)
+        k = KeyMap[k]
+        k = (@names[k.downcase] ||= k)
+        # join multiple values with a comma
+        v = v.to_ary.join(', ') if v.respond_to? :to_ary
+        super(k, v)
+      end
+
+      def fetch(k, *args, &block)
+        k = KeyMap[k]
+        key = @names.fetch(k.downcase, k)
+        super(key, *args, &block)
+      end
+
+      def delete(k)
+        k = KeyMap[k]
+        if k = @names[k.downcase]
+          @names.delete k.downcase
+          super(k)
+        end
+      end
+
+      def include?(k)
+        @names.include? k.downcase
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
+      end
+      alias_method :update, :merge!
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        @names.clear
+        self.update other
+        self
+      end
+
+      def to_hash() ::Hash.new.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.match(/^HTTP\//) } || 0
+        last_response = headers.slice(start_index, headers.size)
+
+        last_response.
+          tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
+          map  { |h| h.split(/:\s*/, 2) }.reject { |p| p[0].nil? }. # split key and value, ignore blank lines
+          each { |key, value|
+            # join multiple values with a comma
+            if self[key]
+              self[key] << ', ' << value
+            else
+              self[key] = value
+            end
+          }
+      end
+
+      protected
+
+      def names
+        @names
+      end
+    end
+
+    # 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_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query, encoder = nil)
+        if query && !query.empty?
+          update((encoder || Utils.default_params_encoder).decode(query))
+        end
+        self
+      end
+
+      def to_query(encoder = nil)
+        (encoder || Utils.default_params_encoder).encode(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
 
     def build_query(params)
       FlatParamsEncoder.encode(params)
@@ -16,19 +197,17 @@ module Faraday
       NestedParamsEncoder.encode(params)
     end
 
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/.freeze
+    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 
-    def escape(str)
-      str.to_s.gsub(ESCAPE_RE) do |match|
+    def escape(s)
+      s.to_s.gsub(ESCAPE_RE) {|match|
         '%' + match.unpack('H2' * match.bytesize).join('%').upcase
-      end.tr(' ', '+')
+      }.tr(' ', '+')
     end
 
-    def unescape(str)
-      CGI.unescape str.to_s
-    end
+    def unescape(s) CGI.unescape s.to_s end
 
-    DEFAULT_SEP = /[&;] */n.freeze
+    DEFAULT_SEP = /[&;] */n
 
     # Adapted from Rack
     def parse_query(query)
@@ -47,18 +226,55 @@ module Faraday
       attr_writer :default_params_encoder
     end
 
+    # Stolen from Rack
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        if params[k]
+          params[k] = Array[params[k]] unless params[k].kind_of?(Array)
+          params[k] << v
+        else
+          params[k] = v
+        end
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
+    end
+
     # Normalize URI() behavior across Ruby versions
     #
     # url - A String or URI.
     #
     # Returns a parsed URI.
-    def URI(url) # rubocop:disable Naming/MethodName
+    def URI(url)
       if url.respond_to?(:host)
         url
       elsif url.respond_to?(:to_str)
         default_uri_parser.call(url)
       else
-        raise ArgumentError, 'bad argument (expected URI object or URI string)'
+        raise ArgumentError, "bad argument (expected URI object or URI string)"
       end
     end
 
@@ -71,28 +287,27 @@ module Faraday
 
     def default_uri_parser=(parser)
       @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
-                              parser
-                            else
-                              parser.method(:parse)
-                            end
+        parser
+      else
+        parser.method(:parse)
+      end
     end
 
-    # Receives a String or URI and returns just
-    # the path with the query string sorted.
+    # Receives a String or URI and returns just the path with the query string sorted.
     def normalize_path(url)
       url = URI(url)
       (url.path.start_with?('/') ? url.path : '/' + url.path) +
-        (url.query ? "?#{sort_query_params(url.query)}" : '')
+      (url.query ? "?#{sort_query_params(url.query)}" : "")
     end
 
     # Recursive hash update
     def deep_merge!(target, hash)
       hash.each do |key, value|
-        target[key] = if value.is_a?(Hash) && target[key].is_a?(Hash)
-                        deep_merge(target[key], value)
-                      else
-                        value
-                      end
+        if Hash === value and Hash === target[key]
+          target[key] = deep_merge(target[key], value)
+        else
+          target[key] = value
+        end
       end
       target
     end
@@ -102,6 +317,8 @@ module Faraday
       deep_merge!(source.dup, hash)
     end
 
+    protected
+
     def sort_query_params(query)
       query.split('&').sort.join('&')
     end