faraday 0.9.1 → 0.11.0

data/lib/faraday/connection.rb

@@ -55,11 +55,11 @@ module Faraday
     #                     :user     - String (optional)
     #                     :password - String (optional)
     def initialize(url = nil, options = nil)
+      options = ConnectionOptions.from(options) unless options and options.is_a?(ConnectionOptions)
+
       if url.is_a?(Hash)
-        options = ConnectionOptions.from(url)
+        options = options.merge(url)
         url     = options.url
-      else
-        options = ConnectionOptions.from(options)
       end
 
       @parallel_manager = nil
@@ -126,7 +126,7 @@ module Faraday
     #     req.body = JSON.generate(:query => {...})
     #   end
     #
-    # Yields a Faraday::Response for further request customizations.
+    # Yields a Faraday::Request for further request customizations.
     # Returns a Faraday::Response.
     #
     # Signature
@@ -163,7 +163,7 @@ module Faraday
     #     req.body = JSON.generate(:user => 'kimchy', ...)
     #   end
     #
-    # Yields a Faraday::Response for further request customizations.
+    # Yields a Faraday::Request for further request customizations.
     # Returns a Faraday::Response.
     #
     # Signature
@@ -358,7 +358,7 @@ module Faraday
     #
     # method  - The Symbol HTTP method.
     # url     - The String or URI to access.
-    # body    - The String body
+    # body    - The request body that will eventually be converted to a string.
     # headers - Hash of unencoded HTTP header key/value pairs.
     #
     # Returns a Faraday::Response.
@@ -396,7 +396,7 @@ module Faraday
     #          of the resulting url (default: nil).
     #
     # Returns the resulting URI instance.
-    def build_exclusive_url(url = nil, params = nil)
+    def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
       url = nil if url.respond_to?(:empty?) and url.empty?
       base = url_prefix
       if url and base.path and base.path !~ /\/$/
@@ -404,7 +404,7 @@ module Faraday
         base.path = base.path + '/'  # ensure trailing slash
       end
       uri = url ? base + url : base
-      uri.query = params.to_query(options.params_encoder) if params
+      uri.query = params.to_query(params_encoder || options.params_encoder) if params
       uri.query = nil if uri.query and uri.query.empty?
       uri
     end
@@ -413,7 +413,12 @@ module Faraday
     #
     # Returns a Faraday::Connection.
     def dup
-      self.class.new(build_exclusive_url, :headers => headers.dup, :params => params.dup, :builder => builder.dup, :ssl => ssl.dup)
+      self.class.new(build_exclusive_url,
+                     :headers => headers.dup,
+                     :params => params.dup,
+                     :builder => builder.dup,
+                     :ssl => ssl.dup,
+                     :request => options.dup)
     end
 
     # Internal: Yields username and password extracted from a URI if they both exist.

data/lib/faraday/error.rb

@@ -29,7 +29,17 @@ module Faraday
     end
 
     def inspect
-      %(#<#{self.class}>)
+      inner = ''
+      if @wrapped_exception
+        inner << " wrapped=#{@wrapped_exception.inspect}"
+      end
+      if @response
+        inner << " response=#{@response.inspect}"
+      end
+      if inner.empty?
+        inner << " #{super}"
+      end
+      %(#<#{self.class}#{inner}>)
     end
   end
 

data/lib/faraday/options.rb

@@ -51,7 +51,14 @@ module Faraday
     def merge(value)
       dup.update(value)
     end
+    
+    # Public
+    def dup
+      self.class.from(self)
+    end
 
+    alias clone dup
+    
     # Public
     def fetch(key, *args)
       unless symbolized_key_set.include?(key.to_sym)
@@ -252,7 +259,8 @@ module Faraday
   end
 
   class Env < Options.new(:method, :body, :url, :request, :request_headers,
-    :ssl, :parallel_manager, :params, :response, :response_headers, :status)
+    :ssl, :parallel_manager, :params, :response, :response_headers, :status,
+    :reason_phrase)
 
     ContentLength = 'Content-Length'.freeze
     StatusesWithoutBody = Set.new [204, 304]
@@ -269,6 +277,15 @@ module Faraday
 
     def_delegators :request, :params_encoder
 
+    # Public
+    def self.from(value)
+      env = super(value)
+      if value.respond_to?(:custom_members)
+        env.custom_members.update(value.custom_members)
+      end
+      env
+    end
+
     # Public
     def [](key)
       if in_member_set?(key)

data/lib/faraday/parameters.rb

@@ -46,6 +46,8 @@ module Faraday
             buffer << "#{to_query.call(new_parent, val)}&"
           end
           return buffer.chop
+        elsif value.nil?
+          return parent
         else
           encoded_value = escape(value)
           return "#{parent}=#{encoded_value}"
@@ -63,50 +65,64 @@ module Faraday
 
     def self.decode(query)
       return nil if query == nil
-      # Recursive helper lambda
-      dehash = lambda do |hash|
-        hash.each do |(key, value)|
-          if value.kind_of?(Hash)
-            hash[key] = dehash.call(value)
+
+      params = {}
+      query.split("&").each do |pair|
+        next if pair.empty?
+        key, value = pair.split("=", 2)
+        key = unescape(key)
+        value = unescape(value.gsub(/\+/, ' ')) if value
+
+        subkeys = key.scan(/[^\[\]]+(?:\]?\[\])?/)
+        context = params
+        subkeys.each_with_index do |subkey, i|
+          is_array = subkey =~ /[\[\]]+\Z/
+          subkey = $` if is_array
+          last_subkey = i == subkeys.length - 1
+
+          if !last_subkey || is_array
+            value_type = is_array ? Array : Hash
+            if context[subkey] && !context[subkey].is_a?(value_type)
+              raise TypeError, "expected %s (got %s) for param `%s'" % [
+                value_type.name,
+                context[subkey].class.name,
+                subkey
+              ]
+            end
+            context = (context[subkey] ||= value_type.new)
           end
-        end
-        # Numeric keys implies an array
-        if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
-          hash.sort.inject([]) do |accu, (_, value)|
-            accu << value; accu
+
+          if context.is_a?(Array) && !is_array
+            if !context.last.is_a?(Hash) || context.last.has_key?(subkey)
+              context << {}
+            end
+            context = context.last
+          end
+
+          if last_subkey
+            if is_array
+              context << value
+            else
+              context[subkey] = value
+            end
           end
-        else
-          hash
         end
       end
 
-      empty_accumulator = {}
-      return ((query.split('&').map do |pair|
-        pair.split('=', 2) if pair && !pair.empty?
-      end).compact.inject(empty_accumulator.dup) do |accu, (key, value)|
-        key = unescape(key)
-        if value.kind_of?(String)
-          value = unescape(value.gsub(/\+/, ' '))
-        end
+      dehash(params, 0)
+    end
 
-        array_notation = !!(key =~ /\[\]$/)
-        subkeys = key.split(/[\[\]]+/)
-        current_hash = accu
-        for i in 0...(subkeys.size - 1)
-          subkey = subkeys[i]
-          current_hash[subkey] = {} unless current_hash[subkey]
-          current_hash = current_hash[subkey]
-        end
-        if array_notation
-          current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
-          current_hash[subkeys.last] << value
-        else
-          current_hash[subkeys.last] = value
-        end
-        accu
-      end).inject(empty_accumulator.dup) do |accu, (key, value)|
-        accu[key] = value.kind_of?(Hash) ? dehash.call(value) : value
-        accu
+    # Internal: convert a nested hash with purely numeric keys into an array.
+    # FIXME: this is not compatible with Rack::Utils.parse_nested_query
+    def self.dehash(hash, depth)
+      hash.each do |key, value|
+        hash[key] = dehash(value, depth + 1) if value.kind_of?(Hash)
+      end
+
+      if depth > 0 && !hash.empty? && hash.keys.all? { |k| k =~ /^\d+$/ }
+        hash.keys.sort.inject([]) { |all, key| all << hash[key] }
+      else
+        hash
       end
     end
   end

data/lib/faraday/rack_builder.rb

@@ -151,8 +151,9 @@ module Faraday
         lock!
         to_app(lambda { |env|
           response = Response.new
-          response.finish(env) unless env.parallel?
           env.response = response
+          response.finish(env) unless env.parallel?
+          response
         })
       end
     end
@@ -188,7 +189,7 @@ module Faraday
     # :ssl - Hash of options for configuring SSL requests.
     def build_env(connection, request)
       Env.new(request.method, request.body,
-        connection.build_exclusive_url(request.path, request.params),
+        connection.build_exclusive_url(request.path, request.params, request.options.params_encoder),
         request.options, request.headers, connection.ssl,
         connection.parallel_manager)
     end

data/lib/faraday/request/authorization.rb

@@ -16,8 +16,7 @@ module Faraday
 
     # Internal
     def self.build_hash(type, hash)
-      offset = KEY.size + type.size + 3
-      comma = ",\n#{' ' * offset}"
+      comma = ", "
       values = []
       hash.each do |key, value|
         values << "#{key}=#{value.to_s.inspect}"

data/lib/faraday/request/retry.rb

@@ -22,12 +22,12 @@ module Faraday
 
     IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
 
-    class Options < Faraday::Options.new(:max, :interval, :interval_randomness, :backoff_factor,
-                                         :exceptions, :methods, :retry_if)
+    class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
+                                         :backoff_factor, :exceptions, :methods, :retry_if)
       DEFAULT_CHECK = lambda { |env,exception| false }
 
       def self.from(value)
-        if Fixnum === value
+        if Integer === value
           new(value)
         else
           super(value)
@@ -42,8 +42,12 @@ module Faraday
         (self[:interval] ||= 0).to_f
       end
 
+      def max_interval
+        (self[:max_interval] ||= Float::MAX).to_f
+      end
+
       def interval_randomness
-        (self[:interval_randomness] ||= 0).to_i
+        (self[:interval_randomness] ||= 0).to_f
       end
 
       def backoff_factor
@@ -73,6 +77,7 @@ module Faraday
     # interval_randomness - The maximum random interval amount expressed
     #                       as a float between 0 and 1 to use in addition to the
     #                       interval. (default: 0)
+    # max_interval        - An upper limit for the interval (default: Float::MAX)
     # backoff_factor      - The amount to multiple each successive retry's
     #                       interval amount by in order to provide backoff
     #                       (default: 1)
@@ -98,6 +103,7 @@ module Faraday
     def sleep_amount(retries)
       retry_index = @options.max - retries
       current_interval = @options.interval * (@options.backoff_factor ** retry_index)
+      current_interval = [current_interval, @options.max_interval].min
       random_interval  = rand * @options.interval_randomness.to_f * @options.interval
       current_interval + random_interval
     end

data/lib/faraday/request.rb

@@ -52,6 +52,8 @@ module Faraday
           path.query = nil
         end
       else
+        anchor_index = path.index('#')
+        path = path.slice(0, anchor_index) unless anchor_index.nil?
         path, query = path.split('?', 2)
       end
       self.path = path

data/lib/faraday/response/logger.rb

@@ -4,7 +4,7 @@ module Faraday
   class Response::Logger < Response::Middleware
     extend Forwardable
 
-    DEFAULT_OPTIONS = { :bodies => false }
+    DEFAULT_OPTIONS = { :headers => true, :bodies => false }
 
     def initialize(app, logger = nil, options = {})
       super(app)
@@ -12,22 +12,28 @@ module Faraday
         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} #{env.url.to_s}"
-      debug('request') { dump_headers env.request_headers }
-      debug('request') { dump_body(env[:body]) } if env[:body] && log_body?(:request)
+      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') { dump_headers env.response_headers }
-      debug('response') { dump_body env[:body] } if env[:body] && log_body?(:response)
+      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
@@ -49,11 +55,26 @@ module Faraday
       body.pretty_inspect
     end
 
+    def log_headers?(type)
+      case @options[:headers]
+      when Hash then @options[:headers][type]
+      else @options[:headers]
+      end
+    end
+
     def log_body?(type)
       case @options[:bodies]
       when Hash then @options[:bodies][type]
       else @options[:bodies]
       end
     end
+
+    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.rb

@@ -37,6 +37,10 @@ module Faraday
       finished? ? env.status : nil
     end
 
+    def reason_phrase
+      finished? ? env.reason_phrase : nil
+    end
+
     def headers
       finished? ? env.response_headers : {}
     end
@@ -61,8 +65,8 @@ module Faraday
 
     def finish(env)
       raise "response already finished" if finished?
-      @on_complete_callbacks.each { |callback| callback.call(env) }
-      @env = Env.from(env)
+      @env = env.is_a?(Env) ? env : Env.from(env)
+      @on_complete_callbacks.each { |callback| callback.call(@env) }
       return self
     end
 

data/lib/faraday/utils.rb

@@ -1,5 +1,4 @@
 require 'thread'
-Faraday.require_libs 'parameters'
 
 module Faraday
   module Utils
@@ -17,6 +16,12 @@ module Faraday
         self.update(hash || {})
       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
 
@@ -81,6 +86,7 @@ module Faraday
 
       def replace(other)
         clear
+        @names.clear
         self.update other
         self
       end
@@ -91,7 +97,7 @@ module Faraday
         return unless header_string && !header_string.empty?
         header_string.split(/\r\n/).
           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
+          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]
@@ -101,6 +107,20 @@ module Faraday
             end
           }
       end
+
+      def init_with(coder)
+        @names = coder['names']
+      end
+
+      def encode_with(coder)
+        coder['names'] = @names
+      end
+
+      protected
+
+      def names
+        @names
+      end
     end
 
     # hash with stringified keys

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.9.1"
+  VERSION = "0.11.0"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.
@@ -34,9 +34,6 @@ module Faraday
     #     Faraday.get "https://faraday.com"
     attr_writer :default_connection
 
-    # Public: Sets the default options used when calling Faraday#new.
-    attr_writer :default_connection_options
-
     # Public: Initializes a new Faraday::Connection.
     #
     # url     - The optional String base URL to use as a prefix for all
@@ -92,6 +89,10 @@ module Faraday
 
     alias require_lib require_libs
 
+    def respond_to?(symbol, include_private = false)
+      default_connection.respond_to?(symbol, include_private) || super
+    end
+
   private
     # Internal: Proxies method calls on the Faraday constant to
     # #default_connection.
@@ -118,13 +119,9 @@ module Faraday
     @default_connection_options ||= ConnectionOptions.new
   end
 
-  if (!defined?(RUBY_ENGINE) || "ruby" == RUBY_ENGINE) && RUBY_VERSION < '1.9'
-    begin
-      require 'system_timer'
-      Timer = SystemTimer
-    rescue LoadError
-      warn "Faraday: you may want to install system_timer for reliable timeouts"
-    end
+  # Public: Sets the default options used when calling Faraday#new.
+  def self.default_connection_options=(options)
+    @default_connection_options = ConnectionOptions.from(options)
   end
 
   unless const_defined? :Timer
@@ -244,25 +241,3 @@ module Faraday
     require_lib 'autoload'
   end
 end
-
-# not pulling in active-support JUST for this method.  And I love this method.
-class Object
-  # The primary purpose of this method is to "tap into" a method chain,
-  # in order to perform operations on intermediate results within the chain.
-  #
-  # Examples
-  #
-  #   (1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
-  #     tap    { |x| puts "array: #{x.inspect}" }.
-  #     select { |x| x%2 == 0 }.
-  #     tap    { |x| puts "evens: #{x.inspect}" }.
-  #     map    { |x| x*x }.
-  #     tap    { |x| puts "squares: #{x.inspect}" }
-  #
-  # Yields self.
-  # Returns self.
-  def tap
-    yield(self)
-    self
-  end unless Object.respond_to?(:tap)
-end