faraday 0.9.0.rc5 → 0.9.0.rc6

data/Gemfile

@@ -1,17 +1,18 @@
 source 'https://rubygems.org'
 
 gem 'ffi-ncurses', '~> 0.3', :platforms => :jruby
-gem 'jruby-openssl', '~> 0.7', :platforms => :jruby
+gem 'jruby-openssl', '~> 0.8.8', :platforms => :jruby
 gem 'rake'
 
 group :test do
   gem 'coveralls', :require => false
-  gem 'em-http-request', '>= 1.0', :require => 'em-http'
-  gem 'em-synchrony', '>= 1.0', :require => ['em-synchrony', 'em-synchrony/em-http']
-  gem 'excon', '>= 0.16.1'
+  gem 'em-http-request', '>= 1.1', :require => 'em-http'
+  gem 'em-synchrony', '>= 1.0.3', :require => ['em-synchrony', 'em-synchrony/em-http']
+  gem 'excon', ['>= 0.25.3', '< 0.27.3']
   gem 'httpclient', '>= 2.2'
   gem 'leftright', '>= 0.9', :require => false
-  gem 'minitest', '>= 4.3'
+  gem 'mime-types', '~> 1.25', :platforms => :ruby_18
+  gem 'minitest', '~> 5.0.5'
   gem 'net-http-persistent', '>= 2.5', :require => false
   gem 'patron', '>= 0.4.2', :platforms => :ruby
   gem 'rack-test', '>= 0.6', :require => 'rack/test'

data/README.md

@@ -24,17 +24,6 @@ conn = Faraday.new(:url => 'http://sushi.com') do |faraday|
   faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
 end
 
-# set proxy with string
-conn.options.proxy = "http://user:password@example.org/"
-
-# set proxy with hash
-conn.options.proxy = { :uri => 'http://user:passwordexample.org' }
-
-# specify proxy user/pass
-conn.options.proxy = { :uri => 'http://user:pass.org',
-  :user => 'user',
-  :password => 'pass' }
-
 ## GET ##
 
 response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
@@ -64,17 +53,6 @@ conn.get do |req|
   req.url '/search'
   req.options.timeout = 5           # open/read timeout in seconds
   req.options.open_timeout = 2      # connection open timeout in seconds
-
-  # set proxy with string
-  req.options.proxy = "http://user:password@example.org/"
-
-  # set proxy with hash
-  req.options.proxy = { :uri => 'http://user:passwordexample.org' }
-
-  # specify proxy user/pass
-  req.options.proxy = { :uri => 'http://user:pass.org',
-    :user => 'user',
-    :password => 'pass' }
 end
 ```
 

data/faraday.gemspec

@@ -17,13 +17,13 @@ Gem::Specification.new do |spec|
   spec.homepage = 'https://github.com/lostisland/faraday'
   spec.licenses = ['MIT']
 
-  spec.add_dependency 'multipart-post', '~> 1.1'
+  spec.add_dependency 'multipart-post', '~> 1.2.0'
   spec.add_development_dependency 'bundler', '~> 1.0'
 
   spec.files = %w(.document CHANGELOG.md CONTRIBUTING.md Gemfile LICENSE.md README.md Rakefile)
   spec.files << "#{lib}.gemspec"
   spec.files += Dir.glob("lib/**/*.rb")
-  spec.files += Dir.glob("test/**/*.rb")
+  spec.files += Dir.glob("test/**/*.{rb,txt}")
   spec.files += Dir.glob("script/*")
 
   dev_null    = File.exist?('/dev/null') ? '/dev/null' : 'NUL'

data/lib/faraday.rb

@@ -14,7 +14,7 @@ require 'forwardable'
 #   conn.get '/'
 #
 module Faraday
-  VERSION = "0.9.0.rc5"
+  VERSION = "0.9.0.rc6"
 
   class << self
     # Public: Gets or sets the root path that Faraday is being loaded from.
@@ -26,7 +26,7 @@ module Faraday
 
     # Public: Gets or sets the Symbol key identifying a default Adapter to use
     # for the default Faraday::Connection.
-    attr_accessor :default_adapter
+    attr_reader :default_adapter
 
     # Public: Sets the default Faraday::Connection for simple scripts that
     # access the Faraday constant directly.
@@ -238,6 +238,10 @@ module Faraday
 
   require_libs "utils", "options", "connection", "rack_builder", "parameters",
     "middleware", "adapter", "request", "response", "upload_io", "error"
+
+  if !ENV["FARADAY_NO_AUTOLOAD"]
+    require_lib 'autoload'
+  end
 end
 
 # not pulling in active-support JUST for this method.  And I love this method.

data/lib/faraday/adapter/em_http.rb

@@ -7,10 +7,10 @@ module Faraday
       module Options
         def connection_config(env)
           options = {}
-          configure_ssl(options, env)
           configure_proxy(options, env)
           configure_timeout(options, env)
           configure_socket(options, env)
+          configure_ssl(options, env)
           options
         end
 
@@ -22,9 +22,6 @@ module Faraday
             # :file => 'path/to/file', # stream data off disk
           }
           configure_compression(options, env)
-          # configure_proxy_auth
-          # :proxy => {:authorization => [user, pass]}
-          # proxy[:username] && proxy[:password]
           options
         end
 
@@ -33,20 +30,12 @@ module Faraday
           body.respond_to?(:read) ? body.read : body
         end
 
-        def configure_ssl(options, env)
-          if ssl = env[:ssl]
-            # :ssl => {
-            #   :private_key_file => '/tmp/server.key',
-            #   :cert_chain_file => '/tmp/server.crt',
-            #   :verify_peer => false
-          end
-        end
-
         def configure_proxy(options, env)
           if proxy = request_options(env)[:proxy]
             options[:proxy] = {
               :host => proxy[:uri].host,
-              :port => proxy[:uri].port
+              :port => proxy[:uri].port,
+              :authorization => [proxy[:user], proxy[:password]]
             }
           end
         end
@@ -60,6 +49,15 @@ module Faraday
           end
         end
 
+        def configure_ssl(options, env)
+          if env[:url].scheme == 'https' && env[:ssl]
+            options[:ssl] = {
+              :cert_chain_file => env[:ssl][:ca_file],
+              :verify_peer => env[:ssl].fetch(:verify, true)
+            }
+          end
+        end
+
         def configure_timeout(options, env)
           timeout, open_timeout = request_options(env).values_at(:timeout, :open_timeout)
           options[:connect_timeout] = options[:inactivity_timeout] = timeout
@@ -124,6 +122,18 @@ module Faraday
               }
           end
         end
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
+      rescue => err
+        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+          raise Faraday::SSLError, err
+        else
+          raise
+        end
       end
 
       # TODO: reuse the connection to support pipelining
@@ -150,6 +160,8 @@ module Faraday
         elsif msg == Errno::ECONNREFUSED
           errklass = Faraday::Error::ConnectionFailed
           msg = "connection refused"
+        elsif msg == "connection closed by server"
+          errklass = Faraday::Error::ConnectionFailed
         end
         raise errklass, msg
       end
@@ -215,3 +227,11 @@ module Faraday
     end
   end
 end
+
+begin
+  require 'openssl'
+rescue LoadError
+  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
+else
+  require 'faraday/adapter/em_http_ssl_patch'
+end if Faraday::Adapter::EMHttp.loaded?

data/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -0,0 +1,56 @@
+require 'openssl'
+require 'em-http'
+
+module EmHttpSslPatch
+  def ssl_verify_peer(cert_string)
+    cert = nil
+    begin
+      cert = OpenSSL::X509::Certificate.new(cert_string)
+    rescue OpenSSL::X509::CertificateError
+      return false
+    end
+
+    @last_seen_cert = cert
+
+    if certificate_store.verify(@last_seen_cert)
+      begin
+        certificate_store.add_cert(@last_seen_cert)
+      rescue OpenSSL::X509::StoreError => e
+        raise e unless e.message == 'cert already in hash table'
+      end
+      true
+    else
+      raise OpenSSL::SSL::SSLError.new(%(unable to verify the server certificate for "#{host}"))
+    end
+  end
+
+  def ssl_handshake_completed
+    return true unless verify_peer?
+
+    unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
+      raise OpenSSL::SSL::SSLError.new(%(host "#{host}" does not match the server certificate))
+    else
+      true
+    end
+  end
+
+  def verify_peer?
+    parent.connopts.tls[:verify_peer]
+  end
+
+  def host
+    parent.connopts.host
+  end
+
+  def certificate_store
+    @certificate_store ||= begin
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      ca_file = parent.connopts.tls[:cert_chain_file]
+      store.add_file(ca_file) if ca_file
+      store
+    end
+  end
+end
+
+EventMachine::HttpStubConnection.send(:include, EmHttpSslPatch)

data/lib/faraday/adapter/em_synchrony.rb

@@ -52,6 +52,8 @@ module Faraday
             client = block.call
           end
 
+          raise client.error if client.error
+
           save_response(env, client.response_header.status, client.response) do |resp_headers|
             client.response_header.each do |name, value|
               resp_headers[name.to_sym] = value
@@ -62,6 +64,18 @@ module Faraday
         @app.call env
       rescue Errno::ECONNREFUSED
         raise Error::ConnectionFailed, $!
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
+      rescue => err
+        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+          raise Faraday::SSLError, err
+        else
+          raise
+        end
       end
     end
   end
@@ -69,23 +83,10 @@ end
 
 require 'faraday/adapter/em_synchrony/parallel_manager'
 
-# add missing patch(), options() methods
-EventMachine::HTTPMethods.module_eval do
-  [:patch, :options].each do |type|
-    next if method_defined? :"a#{type}"
-    alias_method :"a#{type}", type if method_defined? type
-    module_eval %[
-      def #{type}(options = {}, &blk)
-        f = Fiber.current
-        conn = setup_request(:#{type}, options, &blk)
-        if conn.error.nil?
-          conn.callback { f.resume(conn) }
-          conn.errback  { f.resume(conn) }
-          Fiber.yield
-        else
-          conn
-        end
-      end
-    ]
-  end
-end
+begin
+  require 'openssl'
+rescue LoadError
+  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
+else
+  require 'faraday/adapter/em_http_ssl_patch'
+end if Faraday::Adapter::EMSynchrony.loaded?

data/lib/faraday/adapter/excon.rb

@@ -16,6 +16,10 @@ module Faraday
           opts[:ssl_verify_peer] = !!ssl.fetch(:verify, true)
           opts[:ssl_ca_path] = ssl[:ca_path] if ssl[:ca_path]
           opts[:ssl_ca_file] = ssl[:ca_file] if ssl[:ca_file]
+          opts[:client_cert] = ssl[:client_cert] if ssl[:client_cert]
+          opts[:client_key]  = ssl[:client_key]  if ssl[:client_key]
+          opts[:certificate] = ssl[:certificate] if ssl[:certificate]
+          opts[:private_key] = ssl[:private_key] if ssl[:private_key]
 
           # https://github.com/geemus/excon/issues/106
           # https://github.com/jruby/jruby-ossl/issues/19
@@ -33,6 +37,16 @@ module Faraday
             opts[:connect_timeout]   = req[:open_timeout]
             opts[:write_timeout]     = req[:open_timeout]
           end
+
+          if req[:proxy]
+            opts[:proxy] = {
+              :host     => req[:proxy][:uri].host,
+              :port     => req[:proxy][:uri].port,
+              :scheme   => req[:proxy][:uri].scheme,
+              :user     => req[:proxy][:user],
+              :password => req[:proxy][:password]
+            }
+          end
         end
 
         conn = ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
@@ -48,6 +62,8 @@ module Faraday
       rescue ::Excon::Errors::SocketError => err
         if err.message =~ /\btimeout\b/
           raise Error::TimeoutError, err
+        elsif err.message =~ /\bcertificate\b/
+          raise Faraday::SSLError, err
         else
           raise Error::ConnectionFailed, err
         end

data/lib/faraday/adapter/httpclient.rb

@@ -39,6 +39,20 @@ module Faraday
         @app.call env
       rescue ::HTTPClient::TimeoutError
         raise Faraday::Error::TimeoutError, $!
+      rescue ::HTTPClient::BadResponseError => err
+        if err.message.include?('status 407')
+          raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Faraday::Error::ClientError, $!
+        end
+      rescue Errno::ECONNREFUSED, EOFError
+        raise Faraday::Error::ConnectionFailed, $!
+      rescue => err
+        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+          raise Faraday::SSLError, err
+        else
+          raise
+        end
       end
 
       def configure_socket(bind)

data/lib/faraday/adapter/net_http.rb

@@ -36,8 +36,12 @@ module Faraday
 
         begin
           http_response = perform_request(http, env)
-        rescue *NET_HTTP_EXCEPTIONS
-          raise Error::ConnectionFailed, $!
+        rescue *NET_HTTP_EXCEPTIONS => err
+          if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+            raise Faraday::SSLError, err
+          else
+            raise Error::ConnectionFailed, err
+          end
         end
 
         save_response(env, http_response.code.to_i, http_response.body || '') do |response_headers|

data/lib/faraday/adapter/net_http_persistent.rb

@@ -1,4 +1,6 @@
-require 'faraday/adapter/net_http'
+# Rely on autoloading instead of explicit require; helps avoid the "already
+# initialized constant" warning on Ruby 1.8.7 when NetHttp is refereced below.
+# require 'faraday/adapter/net_http'
 
 module Faraday
   class Adapter
@@ -7,8 +9,16 @@ module Faraday
       dependency 'net/http/persistent'
 
       def net_http_connection(env)
-        Net::HTTP::Persistent.new 'Faraday',
-          env[:request][:proxy] ? env[:request][:proxy][:uri] : nil
+        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
+          # awful patch for net-http-persistent 2.8 not unescaping user/password
+          (class << proxy_uri; self; end).class_eval do
+            define_method(:user) { proxy[:user] }
+            define_method(:password) { proxy[:password] }
+          end if proxy[:user]
+        end
+        Net::HTTP::Persistent.new 'Faraday', proxy_uri
       end
 
       def perform_request(http, env)
@@ -16,6 +26,8 @@ module Faraday
       rescue Net::HTTP::Persistent::Error => error
         if error.message.include? 'Timeout'
           raise Faraday::Error::TimeoutError, error
+        elsif error.message.include? 'connection refused'
+          raise Faraday::Error::ConnectionFailed, error
         else
           raise
         end

data/lib/faraday/adapter/patron.rb

@@ -5,7 +5,7 @@ module Faraday
 
       def initialize(app, &block)
         super(app)
-        @block = block if block_given?
+        @block = block
       end
 
       def call(env)
@@ -19,19 +19,19 @@ module Faraday
         if req = env[:request]
           session.timeout = session.connect_timeout = req[:timeout] if req[:timeout]
           session.connect_timeout = req[:open_timeout]              if req[:open_timeout]
-                    
+
           if proxy = req[:proxy]
-            session.proxy = proxy[:uri].to_s
-            if proxy[:user] && proxy[:password]
-              prepend_proxy_auth_string(proxy, session)
-            end
+            proxy_uri = proxy[:uri].dup
+            proxy_uri.user = proxy[:user] && Utils.escape(proxy[:user]).gsub('+', '%20')
+            proxy_uri.password = proxy[:password] && Utils.escape(proxy[:password]).gsub('+', '%20')
+            session.proxy = proxy_uri.to_s
           end
         end
 
         response = begin
           data = env[:body] ? env[:body].to_s : nil
           session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
-        rescue Errno::ECONNREFUSED
+        rescue Errno::ECONNREFUSED, ::Patron::ConnectionFailed
           raise Error::ConnectionFailed, $!
         end
 
@@ -40,6 +40,12 @@ module Faraday
         @app.call env
       rescue ::Patron::TimeoutError => err
         raise Faraday::Error::TimeoutError, err
+      rescue ::Patron::Error => err
+        if err.message.include?("code 407")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
       end
 
       if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
@@ -58,9 +64,5 @@ module Faraday
         session
       end
     end
-    
-    def prepend_proxy_auth_string(proxy, session)
-      session.proxy.insert(7, "#{proxy[:user]}:#{proxy[:password]}@")
-    end
   end
 end