faraday 0.9.0 → 0.9.2

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2009-2013 Rick Olson, Zack Hobson
+Copyright (c) 2009-2015 Rick Olson, Zack Hobson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -6,11 +6,13 @@ processing the request/response cycle.
 
 Faraday supports these adapters:
 
-* Net::HTTP
+* [Net::HTTP][net_http] _(default)_
+* [Net::HTTP::Persistent][persistent]
 * [Excon][]
 * [Typhoeus][]
 * [Patron][]
 * [EventMachine][]
+* [HTTPClient][]
 
 It also includes a Rack adapter for hitting loaded Rack applications through
 Rack::Test, and a Test adapter for stubbing requests by hand.
@@ -29,7 +31,7 @@ end
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
 response.body
 
-conn.get '/nigiri', { :name => 'Maguro' }   # GET /nigiri?name=Maguro
+conn.get '/nigiri', { :name => 'Maguro' }   # GET http://sushi.com/nigiri?name=Maguro
 
 conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100
   req.url '/search', :page => 2
@@ -56,13 +58,39 @@ conn.get do |req|
 end
 ```
 
-If you don't need to set up anything, you can roll with just the bare minimum:
+If you don't need to set up anything, you can roll with just the default middleware
+stack and default adapter (see [Faraday::RackBuilder#initialize](https://github.com/lostisland/faraday/blob/master/lib/faraday/rack_builder.rb)):
 
 ```ruby
-# using the default stack:
 response = Faraday.get 'http://sushi.com/nigiri/sake.json'
 ```
 
+### Changing how parameters are serialized
+
+Sometimes you need to send the same URL parameter multiple times with different
+values. This requires manually setting the parameter encoder and can be done on
+either per-connection or per-request basis.
+
+```ruby
+# per-connection setting
+conn = Faraday.new :params_encoder => Faraday::FlatParamsEncoder
+
+conn.get do |req|
+  # per-request setting:
+  # req.options.params_encoder = my_encoder
+  req.params['roll'] = ['california', 'philadelphia']
+end
+# GET 'http://sushi.com?roll=california&roll=philadelphia'
+```
+
+The value of Faraday `params_encoder` can be any object that responds to:
+
+* `encode(hash) #=> String`
+* `decode(string) #=> Hash`
+
+The encoder will affect both how query strings are processed and how POST bodies
+get serialized. The default encoder is Faraday::NestedParamsEncoder.
+
 ## Advanced middleware usage
 
 The order in which middleware is stacked is important. Like with Rack, the
@@ -106,11 +134,13 @@ Middleware are classes that implement a `call` instance method. They hook into
 the request/response cycle.
 
 ```ruby
-def call(env)
+def call(request_env)
   # do something with the request
+  # request_env[:request_headers].merge!(...)
 
-  @app.call(env).on_complete do
+  @app.call(request_env).on_complete do |response_env|
     # do something with the response
+    # response_env[:response_headers].merge!(...)
   end
 end
 ```
@@ -140,20 +170,20 @@ later, response. Some keys are:
 ```ruby
 # It's possible to define stubbed request outside a test adapter block.
 stubs = Faraday::Adapter::Test::Stubs.new do |stub|
-  stub.get('/tamago') { [200, {}, 'egg'] }
+  stub.get('/tamago') { |env| [200, {}, 'egg'] }
 end
 
 # You can pass stubbed request to the test adapter or define them in a block
 # or a combination of the two.
 test = Faraday.new do |builder|
   builder.adapter :test, stubs do |stub|
-    stub.get('/ebi') {[ 200, {}, 'shrimp' ]}
+    stub.get('/ebi') { |env| [ 200, {}, 'shrimp' ]}
   end
 end
 
 # It's also possible to stub additional requests after the connection has
 # been initialized. This is useful for testing.
-stubs.get('/uni') {[ 200, {}, 'urchin' ]}
+stubs.get('/uni') { |env| [ 200, {}, 'urchin' ]}
 
 resp = test.get '/tamago'
 resp.body # => 'egg'
@@ -180,13 +210,9 @@ stubs.verify_stubbed_calls
 This library aims to support and is [tested against][travis] the following Ruby
 implementations:
 
-* MRI 1.8.7
-* MRI 1.9.2
-* MRI 1.9.3
-* MRI 2.0.0
-* MRI 2.1.0
-* [JRuby][]
-* [Rubinius][]
+* Ruby 1.8.7+
+* [JRuby][] 1.7+
+* [Rubinius][] 2+
 
 If something doesn't work on one of these Ruby versions, it's a bug.
 
@@ -206,11 +232,14 @@ of a major release, support for that Ruby version may be dropped.
 Copyright (c) 2009-2013 [Rick Olson](mailto:technoweenie@gmail.com), Zack Hobson.
 See [LICENSE][] for details.
 
-[travis]:    http://travis-ci.org/lostisland/faraday
-[excon]:     https://github.com/geemus/excon#readme
-[typhoeus]:  https://github.com/typhoeus/typhoeus#readme
-[patron]:    http://toland.github.com/patron/
+[net_http]:     http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/Net/HTTP.html
+[persistent]:   https://github.com/drbrain/net-http-persistent
+[travis]:       http://travis-ci.org/lostisland/faraday
+[excon]:        https://github.com/geemus/excon#readme
+[typhoeus]:     https://github.com/typhoeus/typhoeus#readme
+[patron]:       http://toland.github.com/patron/
 [eventmachine]: https://github.com/igrigorik/em-http-request#readme
-[jruby]:     http://jruby.org/
-[rubinius]:  http://rubini.us/
-[license]:   LICENSE.md
+[httpclient]:   https://github.com/nahi/httpclient
+[jruby]:        http://jruby.org/
+[rubinius]:     http://rubini.us/
+[license]:      LICENSE.md

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.9.0"
+  VERSION = "0.9.2"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.

data/lib/faraday/adapter/em_synchrony.rb

@@ -70,6 +70,14 @@ module Faraday
         else
           raise Error::ConnectionFailed, err
         end
+      rescue Errno::ETIMEDOUT => err
+        raise Error::TimeoutError, err
+      rescue RuntimeError => err
+        if err.message == "connection closed by server"
+          raise Error::ConnectionFailed, err
+        else
+          raise
+        end
       rescue => err
         if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
           raise Faraday::SSLError, err

data/lib/faraday/adapter/excon.rb

@@ -41,6 +41,7 @@ module Faraday
           if req[:proxy]
             opts[:proxy] = {
               :host     => req[:proxy][:uri].host,
+              :hostname => req[:proxy][:uri].hostname,
               :port     => req[:proxy][:uri].port,
               :scheme   => req[:proxy][:uri].scheme,
               :user     => req[:proxy][:user],

data/lib/faraday/adapter/httpclient.rb

@@ -10,6 +10,9 @@ module Faraday
       def call(env)
         super
 
+        # enable compression
+        client.transparent_gzip_decompression = true
+
         if req = env[:request]
           if proxy = req[:proxy]
             configure_proxy proxy
@@ -37,7 +40,7 @@ module Faraday
         save_response env, resp.status, resp.body, resp.headers
 
         @app.call env
-      rescue ::HTTPClient::TimeoutError
+      rescue ::HTTPClient::TimeoutError, Errno::ETIMEDOUT
         raise Faraday::Error::TimeoutError, $!
       rescue ::HTTPClient::BadResponseError => err
         if err.message.include?('status 407')
@@ -69,14 +72,14 @@ module Faraday
 
       def configure_ssl(ssl)
         ssl_config = client.ssl_config
+        ssl_config.verify_mode = ssl_verify_mode(ssl)
+        ssl_config.cert_store = ssl_cert_store(ssl)
 
         ssl_config.add_trust_ca ssl[:ca_file]        if ssl[:ca_file]
         ssl_config.add_trust_ca ssl[:ca_path]        if ssl[:ca_path]
-        ssl_config.cert_store   = ssl[:cert_store]   if ssl[:cert_store]
         ssl_config.client_cert  = ssl[:client_cert]  if ssl[:client_cert]
         ssl_config.client_key   = ssl[:client_key]   if ssl[:client_key]
         ssl_config.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        ssl_config.verify_mode  = ssl_verify_mode(ssl)
       end
 
       def configure_timeouts(req)
@@ -92,6 +95,14 @@ module Faraday
         end
       end
 
+      def ssl_cert_store(ssl)
+        return ssl[:cert_store] if ssl[:cert_store]
+        # Use the default cert store by default, i.e. system ca certs
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        cert_store
+      end
+
       def ssl_verify_mode(ssl)
         ssl[:verify_mode] || begin
           if ssl.fetch(:verify, true)

data/lib/faraday/adapter/net_http.rb

@@ -25,34 +25,36 @@ module Faraday
       ]
 
       NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
+      NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout)
 
       def call(env)
         super
-        http = net_http_connection(env)
-        configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
-
-        req = env[:request]
-        http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
-        http.open_timeout = req[:open_timeout]                if req[:open_timeout]
-
-        begin
-          http_response = perform_request(http, env)
-        rescue *NET_HTTP_EXCEPTIONS => err
-          if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
-            raise Faraday::SSLError, err
-          else
-            raise Error::ConnectionFailed, err
+        with_net_http_connection(env) do |http|
+          configure_ssl(http, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl]
+
+          req = env[:request]
+          http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout]
+          http.open_timeout = req[:open_timeout]                if req[:open_timeout]
+
+          begin
+            http_response = perform_request(http, env)
+          rescue *NET_HTTP_EXCEPTIONS => err
+            if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+              raise Faraday::SSLError, err
+            else
+              raise Error::ConnectionFailed, err
+            end
           end
-        end
 
-        save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|
-          http_response.each_header do |key, value|
-            response_headers[key] = value
+          save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|
+            http_response.each_header do |key, value|
+              response_headers[key] = value
+            end
           end
         end
 
         @app.call env
-      rescue Timeout::Error => err
+      rescue Timeout::Error, Errno::ETIMEDOUT => err
         raise Faraday::Error::TimeoutError, err
       end
 
@@ -81,12 +83,16 @@ module Faraday
         end
       end
 
+      def with_net_http_connection(env)
+        yield net_http_connection(env)
+      end
+
       def net_http_connection(env)
         if proxy = env[:request][:proxy]
           Net::HTTP::Proxy(proxy[:uri].host, proxy[:uri].port, proxy[:user], proxy[:password])
         else
           Net::HTTP
-        end.new(env[:url].host, env[:url].port)
+        end.new(env[:url].host, env[:url].port || (env[:url].scheme == 'https' ? 443 : 80))
       end
 
       def configure_ssl(http, ssl)

data/lib/faraday/adapter/net_http_persistent.rb

@@ -4,11 +4,10 @@
 
 module Faraday
   class Adapter
-    # Experimental adapter for net-http-persistent
     class NetHttpPersistent < NetHttp
       dependency 'net/http/persistent'
 
-      def net_http_connection(env)
+      def with_net_http_connection(env)
         if proxy = env[:request][:proxy]
           proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s)
           proxy_uri.user = proxy_uri.password = nil
@@ -18,11 +17,14 @@ module Faraday
             define_method(:password) { proxy[:password] }
           end if proxy[:user]
         end
-        Net::HTTP::Persistent.new 'Faraday', proxy_uri
+
+        yield Net::HTTP::Persistent.new 'Faraday', proxy_uri
       end
 
       def perform_request(http, env)
         http.request env[:url], create_request(env)
+      rescue Errno::ETIMEDOUT => error
+        raise Faraday::Error::TimeoutError, error
       rescue Net::HTTP::Persistent::Error => error
         if error.message.include? 'Timeout'
           raise Faraday::Error::TimeoutError, error

data/lib/faraday/adapter/patron.rb

@@ -39,7 +39,11 @@ module Faraday
 
         @app.call env
       rescue ::Patron::TimeoutError => err
-        raise Faraday::Error::TimeoutError, err
+        if err.message == "Connection time-out"
+          raise Faraday::Error::ConnectionFailed, err
+        else
+          raise Faraday::Error::TimeoutError, err
+        end
       rescue ::Patron::Error => err
         if err.message.include?("code 407")
           raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
@@ -52,8 +56,14 @@ module Faraday
         # HAX: helps but doesn't work completely
         # https://github.com/toland/patron/issues/34
         ::Patron::Request::VALID_ACTIONS.tap do |actions|
-          actions << :patch unless actions.include? :patch
-          actions << :options unless actions.include? :options
+          if actions[0].is_a?(Symbol)
+            actions << :patch unless actions.include? :patch
+            actions << :options unless actions.include? :options
+          else
+            # Patron 0.4.20 and up
+            actions << "PATCH" unless actions.include? "PATCH"
+            actions << "OPTIONS" unless actions.include? "OPTIONS"
+          end
         end
       end
 

data/lib/faraday/autoload.rb

@@ -69,7 +69,6 @@ module Faraday
       :UrlEncoded => 'url_encoded',
       :Multipart => 'multipart',
       :Retry => 'retry',
-      :Timeout => 'timeout',
       :Authorization => 'authorization',
       :BasicAuthentication => 'basic_authentication',
       :TokenAuthentication => 'token_authentication',

data/lib/faraday/connection.rb

@@ -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/options.rb

@@ -269,6 +269,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

@@ -1,15 +1,10 @@
+require "forwardable"
+
 module Faraday
   module NestedParamsEncoder
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
-
-    def self.escape(s)
-      return s.to_s.gsub(ESCAPE_RE) {
-        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    def self.unescape(s)
-      CGI.unescape(s.to_s)
+    class << self
+      extend Forwardable
+      def_delegators :'Faraday::Utils', :escape, :unescape
     end
 
     def self.encode(params)
@@ -51,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}"
@@ -68,65 +65,72 @@ 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
 
   module FlatParamsEncoder
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
-
-    def self.escape(s)
-      return s.to_s.gsub(ESCAPE_RE) {
-        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    def self.unescape(s)
-      CGI.unescape(s.to_s)
+    class << self
+      extend Forwardable
+      def_delegators :'Faraday::Utils', :escape, :unescape
     end
 
     def self.encode(params)