faraday 0.8.0.rc2 → 0.8.0

data/Gemfile

@@ -8,12 +8,14 @@ group :test do
   gem 'em-http-request', '~> 1.0', :require => 'em-http'
   gem 'em-synchrony', '~> 1.0', :require => ['em-synchrony', 'em-synchrony/em-http'], :platforms => :ruby_19
   gem 'excon', '~> 0.6'
+  gem 'net-http-persistent', '~> 2.5', :require => false
   gem 'leftright', '~> 0.9', :require => false
+  gem 'rack-test', '~> 0.6', :require => 'rack/test'
 end
 
 platforms :ruby do
-  gem 'patron', '~> 0.4'
-  gem 'typhoeus', '~> 0.3'
+  gem 'patron', '~> 0.4', '> 0.4.1'
+  gem 'typhoeus', '~> 0.3', '> 0.3.2'
 end
 
 platforms :jruby do

data/README.md

@@ -1,9 +1,22 @@
-# faraday [![Build Status](https://secure.travis-ci.org/technoweenie/faraday.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/technoweenie/faraday.png?travis)][gemnasium]
-Modular HTTP client library that uses middleware. Heavily inspired by Rack.
-
+# Faraday [![Build Status](https://secure.travis-ci.org/technoweenie/faraday.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/technoweenie/faraday.png?travis)][gemnasium]
 [travis]: http://travis-ci.org/technoweenie/faraday
 [gemnasium]: https://gemnasium.com/technoweenie/faraday
 
+Faraday is an HTTP client lib that provides a common interface over many
+adapters (such as Net::HTTP) and embraces the concept of Rack middleware when
+processing the request/response cycle.
+
+Faraday supports these adapters:
+
+* Net/HTTP
+* Excon
+* Typhoeus
+* Patron
+* EventMachine
+
+It also includes a Rack adapter for hitting loaded Rack applications through
+Rack::Test, and a Test adapter for stubbing requests by hand.
+
 ## <a name="usage"></a>Usage
 
 ```ruby
@@ -23,7 +36,7 @@ end
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
 response.body
 
-conn.get '/nigiri', 'X-Awesome' => true     # custom request header
+conn.get '/nigiri', { :name => 'Maguro' } # GET /nigiri?name=Maguro
 
 conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100
   req.url '/search', :page => 2
@@ -65,24 +78,30 @@ response = Faraday.get 'http://sushi.com/nigiri/sake.json'
 ```
 
 ## Advanced middleware usage
-The order in which middleware is stacked is important. Like with Rack, the first middleware on the list wraps all others, while the last middleware is the innermost one, so that's usually the adapter.
+The order in which middleware is stacked is important. Like with Rack, the
+first middleware on the list wraps all others, while the last middleware is the
+innermost one, so that's usually the adapter.
 
 ```ruby
 conn = Faraday.new(:url => 'http://sushi.com') do |builder|
   # POST/PUT params encoders:
-  builder.request  :multipart
-  builder.request  :url_encoded
+  builder.request :multipart
+  builder.request :url_encoded
 
-  builder.adapter  :net_http
+  builder.adapter :net_http
 end
 ```
 
 This request middleware setup affects POST/PUT requests in the following way:
 
-1. `Request::Multipart` checks for files in the payload, otherwise leaves everything untouched;
-2. `Request::UrlEncoded` encodes as "application/x-www-form-urlencoded" if not already encoded or of another type
+1. `Request::Multipart` checks for files in the payload, otherwise leaves
+  everything untouched;
+2. `Request::UrlEncoded` encodes as "application/x-www-form-urlencoded" if not
+  already encoded or of another type
 
-Swapping middleware means giving the other priority. Specifying the "Content-Type" for the request is explicitly stating which middleware should process it.
+Swapping middleware means giving the other priority. Specifying the
+"Content-Type" for the request is explicitly stating which middleware should
+process it.
 
 Examples:
 
@@ -97,7 +116,8 @@ conn.put '/profile', payload
 ```
 
 ## Writing middleware
-Middleware are classes that respond to `call()`. They wrap the request/response cycle.
+Middleware are classes that respond to `call()`. They wrap the request/response
+cycle.
 
 ```ruby
 def call(env)
@@ -109,9 +129,12 @@ def call(env)
 end
 ```
 
-It's important to do all processing of the response only in the `on_complete` block. This enables middleware to work in parallel mode where requests are asynchronous.
+It's important to do all processing of the response only in the `on_complete`
+block. This enables middleware to work in parallel mode where requests are
+asynchronous.
 
-The `env` is a hash with symbol keys that contains info about the request and, later, response. Some keys are:
+The `env` is a hash with symbol keys that contains info about the request and,
+later, response. Some keys are:
 
 ```
 # request phase
@@ -164,7 +187,6 @@ stubs.verify_stubbed_calls
 ## <a name="todo"></a>TODO
 * support streaming requests/responses
 * better stubbing API
-* Add curb, em-http, fast_http
 
 ## <a name="pulls"></a>Note on Patches/Pull Requests
 1. Fork the project.
@@ -174,7 +196,11 @@ stubs.verify_stubbed_calls
 4. Commit, do not mess with rakefile, version, or history. (if you want to have
    your own version, that is fine but bump version in a commit by itself I can
    ignore when I pull)
-5. Send me a pull request. Bonus points for topic branches.
+5. Send us a pull request. Bonus points for topic branches.
+
+We are pushing towards a 1.0 release, when we will have to follow [Semantic
+Versioning](http://semver.org/).  If your patch includes changes to break
+compatiblitity, note that so we can add it to the [Changelog](https://github.com/technoweenie/faraday/wiki/Changelog).
 
 ## <a name="versions"></a>Supported Ruby Versions
 This library aims to support and is [tested against][travis] the following Ruby
@@ -185,11 +211,9 @@ implementations:
 * Ruby 1.9.3
 * JRuby[]
 * [Rubinius][]
-* [Ruby Enterprise Edition][ree]
 
 [jruby]: http://jruby.org/
 [rubinius]: http://rubini.us/
-[ree]: http://www.rubyenterpriseedition.com/
 
 If something doesn't work on one of these interpreters, it should be considered
 a bug.
@@ -206,6 +230,7 @@ timely fashion. If critical issues for a particular implementation exist at the
 time of a major release, support for that Ruby version may be dropped.
 
 ## <a name="copyright"></a>Copyright
-Copyright (c) 2009 rick olson, zack hobson. See [LICENSE][] for details.
+Copyright (c) 2009-12 [Rick Olson](mailto:technoweenie@gmail.com), zack hobson.
+See [LICENSE][] for details.
 
 [license]: https://github.com/technoweenie/faraday/blob/master/LICENSE.md

data/Rakefile

@@ -51,7 +51,7 @@ desc "Commit, create tag v#{version} and build and push #{gem_file} to Rubygems"
 task :release => :build do
   sh "git commit --allow-empty -a -m 'Release #{version}'"
   sh "git tag v#{version}"
-  sh "git push"
+  sh "git push origin master"
   sh "git push origin v#{version}"
   sh "gem push pkg/#{gem_file}"
 end

data/faraday.gemspec

@@ -3,7 +3,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.5") if s.respond_to? :required_rubygems_version=
 
   s.name    = 'faraday'
-  s.version = '0.8.0.rc2'
+  s.version = '0.8.0'
 
   s.summary     = "HTTP/REST API client library."
   # TODO: s.description
@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'multipart-post', '~> 1.1'
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
   s.add_development_dependency 'test-unit'
   s.add_development_dependency 'webmock'
 
@@ -27,13 +28,14 @@ Gem::Specification.new do |s|
     faraday.gemspec
     lib/faraday.rb
     lib/faraday/adapter.rb
-    lib/faraday/adapter/action_dispatch.rb
     lib/faraday/adapter/em_http.rb
     lib/faraday/adapter/em_synchrony.rb
     lib/faraday/adapter/em_synchrony/parallel_manager.rb
     lib/faraday/adapter/excon.rb
     lib/faraday/adapter/net_http.rb
+    lib/faraday/adapter/net_http_persistent.rb
     lib/faraday/adapter/patron.rb
+    lib/faraday/adapter/rack.rb
     lib/faraday/adapter/test.rb
     lib/faraday/adapter/typhoeus.rb
     lib/faraday/builder.rb
@@ -41,6 +43,7 @@ Gem::Specification.new do |s|
     lib/faraday/error.rb
     lib/faraday/middleware.rb
     lib/faraday/request.rb
+    lib/faraday/request/authorization.rb
     lib/faraday/request/basic_authentication.rb
     lib/faraday/request/multipart.rb
     lib/faraday/request/retry.rb
@@ -51,9 +54,16 @@ Gem::Specification.new do |s|
     lib/faraday/response/raise_error.rb
     lib/faraday/upload_io.rb
     lib/faraday/utils.rb
-    test/adapters/live_test.rb
+    test/adapters/default_test.rb
+    test/adapters/em_http_test.rb
+    test/adapters/em_synchrony_test.rb
+    test/adapters/excon_test.rb
+    test/adapters/integration.rb
     test/adapters/logger_test.rb
+    test/adapters/net_http_persistent_test.rb
     test/adapters/net_http_test.rb
+    test/adapters/patron_test.rb
+    test/adapters/rack_test.rb
     test/adapters/test_middleware_test.rb
     test/adapters/typhoeus_test.rb
     test/authentication_middleware_test.rb

data/lib/faraday.rb

@@ -1,5 +1,5 @@
 module Faraday
-  VERSION = "0.8.0.rc2"
+  VERSION = "0.8.0"
 
   class << self
     attr_accessor :root_path, :lib_path
@@ -33,6 +33,15 @@ module Faraday
     @default_connection ||= Connection.new
   end
 
+  begin
+    require RUBY_VERSION < '1.9' ? 'system_timer' : 'timeout'
+  rescue LoadError
+    require 'timeout'
+    warn "Faraday: you may want to install system_timer for reliable timeouts"
+  ensure
+    Timer = defined?(::SystemTimer) ? ::SystemTimer : ::Timeout
+  end
+
   module MiddlewareRegistry
     # Internal: Register middleware class(es) on the current module.
     #
@@ -116,7 +125,7 @@ module Faraday
 end
 
 
-# not pulling in active-support JUST for this method.
+# not pulling in active-support JUST for this method.  And I love this method.
 class Object
   # Yields <code>x</code> to the block, and then returns <code>x</code>.
   # The primary purpose of this method is to "tap into" a method chain,

data/lib/faraday/adapter.rb

@@ -6,24 +6,26 @@ module Faraday
     extend MiddlewareRegistry
 
     autoload_all 'faraday/adapter',
-      :ActionDispatch => 'action_dispatch',
-      :NetHttp        => 'net_http',
-      :Typhoeus       => 'typhoeus',
-      :EMSynchrony    => 'em_synchrony',
-      :EMHttp         => 'em_http',
-      :Patron         => 'patron',
-      :Excon          => 'excon',
-      :Test           => 'test'
+      :NetHttp           => 'net_http',
+      :NetHttpPersistent => 'net_http_persistent',
+      :Typhoeus          => 'typhoeus',
+      :EMSynchrony       => 'em_synchrony',
+      :EMHttp            => 'em_http',
+      :Patron            => 'patron',
+      :Excon             => 'excon',
+      :Test              => 'test',
+      :Rack              => 'rack'
 
     register_middleware \
-      :action_dispatch => :ActionDispatch,
-      :test            => :Test,
-      :net_http        => :NetHttp,
-      :typhoeus        => :Typhoeus,
-      :patron          => :Patron,
-      :em_synchrony    => :EMSynchrony,
-      :em_http         => :EMHttp,
-      :excon           => :Excon
+      :test                => :Test,
+      :net_http            => :NetHttp,
+      :net_http_persistent => :NetHttpPersistent,
+      :typhoeus            => :Typhoeus,
+      :patron              => :Patron,
+      :em_synchrony        => :EMSynchrony,
+      :em_http             => :EMHttp,
+      :excon               => :Excon,
+      :rack                => :Rack
 
     module Parallelism
       attr_writer :supports_parallel

data/lib/faraday/adapter/net_http.rb

@@ -8,59 +8,32 @@ end
 module Faraday
   class Adapter
     class NetHttp < Faraday::Adapter
-      def call(env)
-        super
-        url = env[:url]
-        req = env[:request]
+      NET_HTTP_EXCEPTIONS = [
+        EOFError,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EINVAL,
+        Net::HTTPBadResponse,
+        Net::HTTPHeaderSyntaxError,
+        Net::ProtocolError,
+        SocketError
+      ]
 
-        http = net_http_class(env).new(url.host, url.port)
-
-        if http.use_ssl = (url.scheme == 'https' && (ssl = env[:ssl]) && true)
-          http.verify_mode = ssl[:verify_mode] || begin
-            if ssl.fetch(:verify, true)
-              # Use the default cert store by default, i.e. system ca certs
-              store = OpenSSL::X509::Store.new
-              store.set_default_paths
-              http.cert_store = store
-              OpenSSL::SSL::VERIFY_PEER
-            else
-              OpenSSL::SSL::VERIFY_NONE
-            end
-          end
+      NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL)
 
-          http.cert         = ssl[:client_cert]  if ssl[:client_cert]
-          http.key          = ssl[:client_key]   if ssl[:client_key]
-          http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
-          http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
-          http.cert_store   = ssl[:cert_store]   if ssl[:cert_store]
-          http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
-        end
+      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]
 
-        if :get != env[:method] or env[:body]
-          http_request = Net::HTTPGenericRequest.new \
-            env[:method].to_s.upcase,    # request method
-            !!env[:body],                # is there request body
-            :head != env[:method],       # is there response body
-            url.request_uri,             # request uri path
-            env[:request_headers]        # request headers
-
-          if env[:body].respond_to?(:read)
-            http_request.body_stream = env[:body]
-            env[:body] = nil
-          end
-        end
-
         begin
-          http_response = if :get == env[:method] and env[:body].nil?
-            # prefer `get` to `request` because the former handles gzip (ruby 1.9)
-            http.get url.request_uri, env[:request_headers]
-          else
-            http.request http_request, env[:body]
-          end
-        rescue Errno::ECONNREFUSED
+          http_response = perform_request(http, env)
+        rescue *NET_HTTP_EXCEPTIONS
           raise Error::ConnectionFailed, $!
         end
 
@@ -75,11 +48,67 @@ module Faraday
         raise Faraday::Error::TimeoutError, err
       end
 
-      def net_http_class(env)
+      def create_request(env)
+        request = Net::HTTPGenericRequest.new \
+          env[:method].to_s.upcase,    # request method
+          !!env[:body],                # is there request body
+          :head != env[:method],       # is there response body
+          env[:url].request_uri,       # request uri path
+          env[:request_headers]        # request headers
+
+        if env[:body].respond_to?(:read)
+          request.body_stream = env[:body]
+        else
+          request.body = env[:body]
+        end
+        request
+      end
+
+      def perform_request(http, env)
+        if :get == env[:method] and !env[:body]
+          # prefer `get` to `request` because the former handles gzip (ruby 1.9)
+          http.get env[:url].request_uri, env[:request_headers]
+        else
+          http.request create_request(env)
+        end
+      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
+
+      def configure_ssl(http, ssl)
+        http.use_ssl      = true
+        http.verify_mode  = ssl_verify_mode(ssl)
+        http.cert_store   = ssl_cert_store(ssl)
+
+        http.cert         = ssl[:client_cert]  if ssl[:client_cert]
+        http.key          = ssl[:client_key]   if ssl[:client_key]
+        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
+        http.ca_path      = ssl[:ca_path]      if ssl[:ca_path]
+        http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth]
+        http.ssl_version  = ssl[:version]      if ssl[:version]
+      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)
+            OpenSSL::SSL::VERIFY_PEER
+          else
+            OpenSSL::SSL::VERIFY_NONE
+          end
         end
       end
     end

data/lib/faraday/adapter/net_http_persistent.rb

@@ -0,0 +1,37 @@
+require 'faraday/adapter/net_http'
+
+module Faraday
+  class Adapter
+    # Experimental adapter for net-http-persistent
+    class NetHttpPersistent < NetHttp
+      dependency 'net/http/persistent'
+
+      # TODO: investigate is it safe to create a new Persistent instance for
+      # every request, or does it defy the purpose of persistent connections
+      def net_http_connection(env)
+        Net::HTTP::Persistent.new 'Faraday',
+          env[:request][:proxy] ? env[:request][:proxy][:uri] : nil
+      end
+
+      def perform_request(http, env)
+        http.request env[:url], create_request(env)
+      rescue Net::HTTP::Persistent::Error => error
+        if error.message.include? 'Timeout::Error'
+          raise Faraday::Error::TimeoutError, error
+        else
+          raise
+        end
+      end
+
+      def configure_ssl(http, ssl)
+        http.verify_mode  = ssl_verify_mode(ssl)
+        http.cert_store   = ssl_cert_store(ssl)
+
+        http.certificate  = ssl[:client_cert]  if ssl[:client_cert]
+        http.private_key  = ssl[:client_key]   if ssl[:client_key]
+        http.ca_file      = ssl[:ca_file]      if ssl[:ca_file]
+        http.ssl_version  = ssl[:version]      if ssl[:version]
+      end
+    end
+  end
+end