faraday 0.8.11 → 0.9.0

data/lib/faraday/adapter/test.rb

@@ -21,53 +21,52 @@ module Faraday
         def initialize
           # {:get => [Stub, Stub]}
           @stack, @consumed = {}, {}
-          yield self if block_given?
+          yield(self) if block_given?
         end
 
         def empty?
           @stack.empty?
         end
 
-        def match(request_method, path, body)
+        def match(request_method, path, headers, body)
           return false if !@stack.key?(request_method)
           stack = @stack[request_method]
           consumed = (@consumed[request_method] ||= [])
-          path = normalize_path(path)
 
-          if stub = matches?(stack, path, body)
+          if stub = matches?(stack, path, headers, body)
             consumed << stack.delete(stub)
             stub
           else
-            matches?(consumed, path, body)
+            matches?(consumed, path, headers, body)
           end
         end
 
-        def get(path, &block)
-          new_stub(:get, path, &block)
+        def get(path, headers = {}, &block)
+          new_stub(:get, path, headers, &block)
         end
 
-        def head(path, &block)
-          new_stub(:head, path, &block)
+        def head(path, headers = {}, &block)
+          new_stub(:head, path, headers, &block)
         end
 
-        def post(path, body=nil, &block)
-          new_stub(:post, path, body, &block)
+        def post(path, body=nil, headers = {}, &block)
+          new_stub(:post, path, headers, body, &block)
         end
 
-        def put(path, body=nil, &block)
-          new_stub(:put, path, body, &block)
+        def put(path, body=nil, headers = {}, &block)
+          new_stub(:put, path, headers, body, &block)
         end
 
-        def patch(path, body=nil, &block)
-          new_stub(:patch, path, body, &block)
+        def patch(path, body=nil, headers = {}, &block)
+          new_stub(:patch, path, headers, body, &block)
         end
 
-        def delete(path, &block)
-          new_stub(:delete, path, &block)
+        def delete(path, headers = {}, &block)
+          new_stub(:delete, path, headers, &block)
         end
 
-        def options(path, &block)
-          new_stub(:options, path, &block)
+        def options(path, headers = {}, &block)
+          new_stub(:options, path, headers, &block)
         end
 
         # Raises an error if any of the stubbed calls have not been made.
@@ -85,40 +84,34 @@ module Faraday
 
         protected
 
-        def new_stub(request_method, path, body=nil, &block)
-          (@stack[request_method] ||= []) << Stub.new(normalize_path(path), body, block)
+        def new_stub(request_method, path, headers = {}, body=nil, &block)
+          normalized_path = Faraday::Utils.normalize_path(path)
+          (@stack[request_method] ||= []) << Stub.new(normalized_path, headers, body, block)
         end
 
-        def matches?(stack, path, body)
-          stack.detect { |stub| stub.matches?(path, body) }
-        end
-
-        # ensure leading + trailing slash
-        def normalize_path(path)
-          path = '/' + path if path.index('/') != 0
-          path = path.sub('?', '/?')
-          path = path + '/' unless $&
-          path.gsub('//', '/')
+        def matches?(stack, path, headers, body)
+          stack.detect { |stub| stub.matches?(path, headers, body) }
         end
       end
 
-      class Stub < Struct.new(:path, :params, :body, :block)
-        def initialize(full, body, block)
+      class Stub < Struct.new(:path, :params, :headers, :body, :block)
+        def initialize(full, headers, body, block)
           path, query = full.split('?')
           params = query ?
             Faraday::Utils.parse_nested_query(query) :
             {}
-          super path, params, body, block
+          super(path, params, headers, body, block)
         end
 
-        def matches?(request_uri, request_body)
+        def matches?(request_uri, request_headers, request_body)
           request_path, request_query = request_uri.split('?')
           request_params = request_query ?
             Faraday::Utils.parse_nested_query(request_query) :
             {}
           request_path == path &&
             params_match?(request_params) &&
-            (body.to_s.size.zero? || request_body == body)
+            (body.to_s.size.zero? || request_body == body) &&
+            headers_match?(request_headers)
         end
 
         def params_match?(request_params)
@@ -127,6 +120,12 @@ module Faraday
           end
         end
 
+        def headers_match?(request_headers)
+          headers.keys.all? do |key|
+            request_headers[key] == headers[key]
+          end
+        end
+
         def to_s
           "#{path} #{body}"
         end
@@ -139,16 +138,17 @@ module Faraday
       end
 
       def configure
-        yield stubs
+        yield(stubs)
       end
 
       def call(env)
         super
         normalized_path = Faraday::Utils.normalize_path(env[:url])
+        params_encoder = env.request.params_encoder || Faraday::Utils.default_params_encoder
 
-        if stub = stubs.match(env[:method], normalized_path, env[:body])
+        if stub = stubs.match(env[:method], normalized_path, env.request_headers, env[:body])
           env[:params] = (query = env[:url].query) ?
-            Faraday::Utils.parse_nested_query(query)  :
+            params_encoder.decode(query)  :
             {}
           status, headers, body = stub.block.call(env)
           save_response(env, status, body, headers)

data/lib/faraday/adapter/typhoeus.rb

@@ -40,11 +40,12 @@ module Faraday
           :method  => method,
           :body    => env[:body],
           :headers => env[:request_headers],
-          :disable_ssl_peer_verification => (env[:ssl] && !env[:ssl].fetch(:verify, true))
+          :disable_ssl_peer_verification => (env[:ssl] && env[:ssl].disable?)
 
         configure_ssl     req, env
         configure_proxy   req, env
         configure_timeout req, env
+        configure_socket  req, env
 
         req.on_complete do |resp|
           if resp.timed_out?
@@ -60,6 +61,8 @@ module Faraday
             # everything OK
           when 7
             raise Error::ConnectionFailed, resp.curl_error_message
+          when 60
+            raise Faraday::SSLError, resp.curl_error_message
           else
             raise Error::ClientError, resp.curl_error_message
           end
@@ -78,8 +81,8 @@ module Faraday
         ssl = env[:ssl]
 
         req.ssl_version = ssl[:version]          if ssl[:version]
-        req.ssl_cert    = ssl[:client_cert_file] if ssl[:client_cert_file]
-        req.ssl_key     = ssl[:client_key_file]  if ssl[:client_key_file]
+        req.ssl_cert    = ssl[:client_cert] if ssl[:client_cert]
+        req.ssl_key     = ssl[:client_key]  if ssl[:client_key]
         req.ssl_cacert  = ssl[:ca_file]          if ssl[:ca_file]
         req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
       end
@@ -102,6 +105,12 @@ module Faraday
         req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
       end
 
+      def configure_socket(req, env)
+        if bind = request_options(env)[:bind]
+          req.interface = bind[:host]
+        end
+      end
+
       def request_options(env)
         env[:request]
       end

data/lib/faraday/adapter.rb

@@ -1,32 +1,22 @@
 module Faraday
+  # Public: This is a base class for all Faraday adapters.  Adapters are
+  # responsible for fulfilling a Faraday request.
   class Adapter < Middleware
     CONTENT_LENGTH = 'Content-Length'.freeze
 
-    extend AutoloadHelper
-    extend MiddlewareRegistry
-
-    autoload_all 'faraday/adapter',
-      :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 \
-      :test                => :Test,
-      :net_http            => :NetHttp,
-      :net_http_persistent => :NetHttpPersistent,
-      :typhoeus            => :Typhoeus,
-      :patron              => :Patron,
-      :em_synchrony        => :EMSynchrony,
-      :em_http             => :EMHttp,
-      :excon               => :Excon,
-      :rack                => :Rack
-
+    register_middleware File.expand_path('../adapter', __FILE__),
+      :test => [:Test, 'test'],
+      :net_http => [:NetHttp, 'net_http'],
+      :net_http_persistent => [:NetHttpPersistent, 'net_http_persistent'],
+      :typhoeus => [:Typhoeus, 'typhoeus'],
+      :patron => [:Patron, 'patron'],
+      :em_synchrony => [:EMSynchrony, 'em_synchrony'],
+      :em_http => [:EMHttp, 'em_http'],
+      :excon => [:Excon, 'excon'],
+      :rack => [:Rack, 'rack'],
+      :httpclient => [:HTTPClient, 'httpclient']
+
+    # Public: This module marks an Adapter as supporting parallel requests.
     module Parallelism
       attr_writer :supports_parallel
       def supports_parallel?() @supports_parallel end
@@ -41,20 +31,15 @@ module Faraday
     self.supports_parallel = false
 
     def call(env)
-      if !env[:body] and Connection::METHODS_WITH_BODIES.include? env[:method]
-        # play nice and indicate we're sending an empty body
-        env[:request_headers][CONTENT_LENGTH] = "0"
-        # Typhoeus hangs on PUT requests if body is nil
-        env[:body] = ''
-      end
+      env.clear_body if env.needs_body?
     end
 
     def save_response(env, status, body, headers = nil)
-      env[:status] = status
-      env[:body] = body
-      env[:response_headers] = Utils::Headers.new.tap do |response_headers|
+      env.status = status
+      env.body = body
+      env.response_headers = Utils::Headers.new.tap do |response_headers|
         response_headers.update headers unless headers.nil?
-        yield response_headers if block_given?
+        yield(response_headers) if block_given?
       end
     end
   end

data/lib/faraday/autoload.rb

@@ -0,0 +1,85 @@
+module Faraday
+  # Internal: Adds the ability for other modules to manage autoloadable
+  # constants.
+  module AutoloadHelper
+    # Internal: Registers the constants to be auto loaded.
+    #
+    # prefix  - The String require prefix.  If the path is inside Faraday, then
+    #           it will be prefixed with the root path of this loaded Faraday
+    #           version.
+    # options - Hash of Symbol => String library names.
+    #
+    # Examples.
+    #
+    #   Faraday.autoload_all 'faraday/foo',
+    #     :Bar => 'bar'
+    #
+    #   # requires faraday/foo/bar to load Faraday::Bar.
+    #   Faraday::Bar
+    #
+    #
+    # Returns nothing.
+    def autoload_all(prefix, options)
+      if prefix =~ /^faraday(\/|$)/i
+        prefix = File.join(Faraday.root_path, prefix)
+      end
+      options.each do |const_name, path|
+        autoload const_name, File.join(prefix, path)
+      end
+    end
+
+    # Internal: Loads each autoloaded constant.  If thread safety is a concern,
+    # wrap this in a Mutex.
+    #
+    # Returns nothing.
+    def load_autoloaded_constants
+      constants.each do |const|
+        const_get(const) if autoload?(const)
+      end
+    end
+
+    # Internal: Filters the module's contents with those that have been already
+    # autoloaded.
+    #
+    # Returns an Array of Class/Module objects.
+    def all_loaded_constants
+      constants.map { |c| const_get(c) }.
+        select { |a| a.respond_to?(:loaded?) && a.loaded? }
+    end
+  end
+
+  class Adapter
+    extend AutoloadHelper
+    autoload_all 'faraday/adapter',
+      :NetHttp           => 'net_http',
+      :NetHttpPersistent => 'net_http_persistent',
+      :Typhoeus          => 'typhoeus',
+      :EMSynchrony       => 'em_synchrony',
+      :EMHttp            => 'em_http',
+      :Patron            => 'patron',
+      :Excon             => 'excon',
+      :Test              => 'test',
+      :Rack              => 'rack',
+      :HTTPClient        => 'httpclient'
+  end
+
+  class Request
+    extend AutoloadHelper
+    autoload_all 'faraday/request',
+      :UrlEncoded => 'url_encoded',
+      :Multipart => 'multipart',
+      :Retry => 'retry',
+      :Timeout => 'timeout',
+      :Authorization => 'authorization',
+      :BasicAuthentication => 'basic_authentication',
+      :TokenAuthentication => 'token_authentication',
+      :Instrumentation => 'instrumentation'
+  end
+
+  class Response
+    extend AutoloadHelper
+    autoload_all 'faraday/response',
+      :RaiseError => 'raise_error',
+      :Logger     => 'logger'
+  end
+end