faraday 0.6.0 → 0.8.0

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

data/lib/faraday/adapter/patron.rb

@@ -3,29 +3,63 @@ module Faraday
     class Patron < Faraday::Adapter
       dependency 'patron'
 
+      def initialize(app, &block)
+        super(app)
+        @block = block if block_given?
+      end
+
       def call(env)
         super
 
         # TODO: support streaming requests
         env[:body] = env[:body].read if env[:body].respond_to? :read
 
-        session = ::Patron::Session.new
+        session = @session ||= create_session
 
-        response = begin
-          if Connection::METHODS_WITH_BODIES.include? env[:method]
-            session.send(env[:method], env[:url].to_s, env[:body].to_s, env[:request_headers])
-          else
-            session.send(env[:method], env[:url].to_s, env[:request_headers])
+        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
           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
           raise Error::ConnectionFailed, $!
         end
 
-        env.update :status => response.status, :body => response.body
-        response_headers(env).update response.headers
+        save_response(env, response.status, response.body, response.headers)
 
         @app.call env
+      rescue ::Patron::TimeoutError => err
+        raise Faraday::Error::TimeoutError, err
       end
+
+      if loaded? && defined?(::Patron::Request::VALID_ACTIONS)
+        # 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
+        end
+      end
+
+      def create_session
+        session = ::Patron::Session.new
+        @block.call(session) if @block
+        session
+      end
+    end
+    
+    def prepend_proxy_auth_string(proxy, session)
+      session.proxy.insert(7, "#{proxy[:user]}:#{proxy[:password]}@")
     end
   end
 end

data/lib/faraday/adapter/rack.rb

@@ -0,0 +1,59 @@
+require 'timeout'
+
+module Faraday
+  class Adapter
+    # Sends requests to a Rack app.
+    #
+    # Examples
+    #
+    #   class MyRackApp
+    #     def call(env)
+    #       [200, {'Content-Type' => 'text/html'}, ["hello world"]]
+    #     end
+    #   end
+    #
+    #   Faraday.new do |conn|
+    #     conn.adapter :rack, MyRackApp
+    #   end
+    class Rack < Faraday::Adapter
+      dependency 'rack/test'
+
+      # not prefixed with "HTTP_"
+      SPECIAL_HEADERS = %w[ CONTENT_LENGTH CONTENT_TYPE ]
+
+      def initialize(faraday_app, rack_app)
+        super(faraday_app)
+        mock_session = ::Rack::MockSession.new(rack_app)
+        @session     = ::Rack::Test::Session.new(mock_session)
+      end
+
+      def call(env)
+        super
+        rack_env = {
+          :method => env[:method],
+          :input  => env[:body].respond_to?(:read) ? env[:body].read : env[:body]
+        }
+
+        env[:request_headers].each do |name, value|
+          name = name.upcase.tr('-', '_')
+          name = "HTTP_#{name}" unless SPECIAL_HEADERS.include? name
+          rack_env[name] = value
+        end if env[:request_headers]
+
+        timeout  = env[:request][:timeout] || env[:request][:open_timeout]
+        response = if timeout
+          Timer.timeout(timeout, Faraday::Error::TimeoutError) { execute_request(env, rack_env) }
+        else
+          execute_request(env, rack_env)
+        end
+
+        save_response(env, response.status, response.body, response.headers)
+        @app.call env
+      end
+
+      def execute_request(env, rack_env)
+        @session.request(env[:url].to_s, rack_env)
+      end
+    end
+  end
+end

data/lib/faraday/adapter/test.rb

@@ -14,9 +14,10 @@ module Faraday
     class Test < Faraday::Adapter
       attr_accessor :stubs
 
-      def self.loaded?() false end
-
       class Stubs
+        class NotFound < StandardError
+        end
+
         def initialize
           # {:get => [Stub, Stub]}
           @stack, @consumed = {}, {}
@@ -31,6 +32,7 @@ module Faraday
           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)
             consumed << stack.delete(stub)
@@ -56,10 +58,18 @@ module Faraday
           new_stub(:put, path, body, &block)
         end
 
+        def patch(path, body=nil, &block)
+          new_stub(:patch, path, body, &block)
+        end
+
         def delete(path, &block)
           new_stub(:delete, path, &block)
         end
 
+        def options(path, &block)
+          new_stub(:options, path, &block)
+        end
+
         # Raises an error if any of the stubbed calls have not been made.
         def verify_stubbed_calls
           failed_stubs = []
@@ -76,17 +86,45 @@ module Faraday
         protected
 
         def new_stub(request_method, path, body=nil, &block)
-          (@stack[request_method] ||= []) << Stub.new(path, body, block)
+          (@stack[request_method] ||= []) << Stub.new(normalize_path(path), 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('//', '/')
+        end
       end
 
-      class Stub < Struct.new(:path, :body, :block)
-        def matches?(request_path, request_body)
-          request_path == path && (body.to_s.size.zero? || request_body == body)
+      class Stub < Struct.new(:path, :params, :body, :block)
+        def initialize(full, body, block)
+          path, query = full.split('?')
+          params = query ?
+            Faraday::Utils.parse_nested_query(query) :
+            {}
+          super path, params, body, block
+        end
+
+        def matches?(request_uri, 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)
+        end
+
+        def params_match?(request_params)
+          params.keys.all? do |key|
+            request_params[key] == params[key]
+          end
         end
 
         def to_s
@@ -109,11 +147,13 @@ module Faraday
         normalized_path = Faraday::Utils.normalize_path(env[:url])
 
         if stub = stubs.match(env[:method], normalized_path, env[:body])
+          env[:params] = (query = env[:url].query) ?
+            Faraday::Utils.parse_nested_query(query)  :
+            {}
           status, headers, body = stub.block.call(env)
-          env.update :status => status, :body => body
-          response_headers(env).update headers
+          save_response(env, status, body, headers)
         else
-          raise "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"
+          raise Stubs::NotFound, "no stubbed request for #{env[:method]} #{normalized_path} #{env[:body]}"
         end
         @app.call(env)
       end

data/lib/faraday/adapter/typhoeus.rb

@@ -1,7 +1,7 @@
 module Faraday
   class Adapter
     class Typhoeus < Faraday::Adapter
-      self.supports_parallel_requests = true
+      self.supports_parallel = true
 
       def self.setup_parallel_manager(options = {})
         options.empty? ? ::Typhoeus::Hydra.hydra : ::Typhoeus::Hydra.new(options)
@@ -11,34 +11,89 @@ module Faraday
 
       def call(env)
         super
+        perform_request env
+        @app.call env
+      end
+
+      def perform_request(env)
+        read_body env
+
+        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
+        hydra.queue request(env)
+        hydra.run unless parallel?(env)
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, $!
+      end
 
-        # TODO: support streaming requests
+      # TODO: support streaming requests
+      def read_body(env)
         env[:body] = env[:body].read if env[:body].respond_to? :read
+      end
 
+      def request(env)
         req = ::Typhoeus::Request.new env[:url].to_s,
           :method  => env[:method],
           :body    => env[:body],
           :headers => env[:request_headers],
           :disable_ssl_peer_verification => (env[:ssl] && !env[:ssl].fetch(:verify, true))
 
-        env_req = env[:request]
-        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
-        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
+        configure_ssl     req, env
+        configure_proxy   req, env
+        configure_timeout req, env
 
-        is_parallel = !!env[:parallel_manager]
         req.on_complete do |resp|
-          env.update :status => resp.code, :body => resp.body
-          response_headers(env).parse resp.headers
-          env[:response].finish(env) if is_parallel
+          if resp.timed_out?
+            if parallel?(env)
+              # TODO: error callback in async mode
+            else
+              raise Faraday::Error::TimeoutError, "request timed out"
+            end
+          end
+
+          save_response(env, resp.code, resp.body) do |response_headers|
+            response_headers.parse resp.headers
+          end
+          # in async mode, :response is initialized at this point
+          env[:response].finish(env) if parallel?(env)
         end
 
-        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
-        hydra.queue req
-        hydra.run unless is_parallel
+        req
+      end
 
-        @app.call env
-      rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, $!
+      def configure_ssl(req, env)
+        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_cacert  = ssl[:ca_file]          if ssl[:ca_file]
+        req.ssl_capath  = ssl[:ca_path]          if ssl[:ca_path]
+      end
+
+      def configure_proxy(req, env)
+        proxy = request_options(env)[:proxy]
+        return unless proxy
+
+        req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
+
+        if proxy[:username] && proxy[:password]
+          req.proxy_username = proxy[:username]
+          req.proxy_password = proxy[:password]
+        end
+      end
+
+      def configure_timeout(req, env)
+        env_req = request_options(env)
+        req.timeout = req.connect_timeout = (env_req[:timeout] * 1000) if env_req[:timeout]
+        req.connect_timeout = (env_req[:open_timeout] * 1000)          if env_req[:open_timeout]
+      end
+
+      def request_options(env)
+        env[:request]
+      end
+
+      def parallel?(env)
+        !!env[:parallel_manager]
       end
     end
   end

data/lib/faraday/adapter.rb

@@ -3,24 +3,42 @@ module Faraday
     CONTENT_LENGTH = 'Content-Length'.freeze
 
     extend AutoloadHelper
+    extend MiddlewareRegistry
 
     autoload_all 'faraday/adapter',
-      :ActionDispatch => 'action_dispatch',
-      :NetHttp        => 'net_http',
-      :Typhoeus       => 'typhoeus',
-      :EMSynchrony    => 'em_synchrony',
-      :Patron         => 'patron',
-      :Excon          => 'excon',
-      :Test           => 'test'
-
-    register_lookup_modules \
-      :action_dispatch => :ActionDispatch,
-      :test            => :Test,
-      :net_http        => :NetHttp,
-      :typhoeus        => :Typhoeus,
-      :patron          => :Patron,
-      :em_synchrony    => :EMSynchrony,
-      :excon           => :Excon
+      :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
+
+    module Parallelism
+      attr_writer :supports_parallel
+      def supports_parallel?() @supports_parallel end
+
+      def inherited(subclass)
+        super
+        subclass.supports_parallel = self.supports_parallel?
+      end
+    end
+
+    extend Parallelism
+    self.supports_parallel = false
 
     def call(env)
       if !env[:body] and Connection::METHODS_WITH_BODIES.include? env[:method]
@@ -31,8 +49,13 @@ module Faraday
       end
     end
 
-    def response_headers(env)
-      env[:response_headers] ||= Utils::Headers.new
+    def save_response(env, status, body, headers = nil)
+      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?
+      end
     end
   end
 end

data/lib/faraday/builder.rb

@@ -8,9 +8,8 @@ module Faraday
   class Builder
     attr_accessor :handlers
 
-    def self.create
-      new { |builder| yield builder }
-    end
+    # Error raised when trying to modify the stack after calling `lock!`
+    class StackLocked < RuntimeError; end
 
     # borrowed from ActiveSupport::Dependencies::Reference &
     # ActionDispatch::MiddlewareStack::Middleware
@@ -31,7 +30,9 @@ module Faraday
       def inspect() @name end
 
       def ==(other)
-        if other.respond_to? :name
+        if other.is_a? Handler
+          self.name == other.name
+        elsif other.respond_to? :name
           klass == other
         else
           @name == other.to_s
@@ -55,6 +56,7 @@ module Faraday
     end
 
     def build(options = {})
+      raise_if_locked
       @handlers.clear unless options[:keep]
       yield self if block_given?
     end
@@ -76,29 +78,40 @@ module Faraday
       @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
     end
 
-    def use(klass, *args)
-      block = block_given? ? Proc.new : nil
-      @handlers << self.class::Handler.new(klass, *args, &block)
+    # Locks the middleware stack to ensure no further modifications are possible.
+    def lock!
+      @handlers.freeze
+    end
+
+    def locked?
+      @handlers.frozen?
+    end
+
+    def use(klass, *args, &block)
+      if klass.is_a? Symbol
+        use_symbol(Faraday::Middleware, klass, *args, &block)
+      else
+        raise_if_locked
+        @handlers << self.class::Handler.new(klass, *args, &block)
+      end
     end
 
-    def request(key, *args)
-      block = block_given? ? Proc.new : nil
+    def request(key, *args, &block)
       use_symbol(Faraday::Request, key, *args, &block)
     end
 
-    def response(key, *args)
-      block = block_given? ? Proc.new : nil
+    def response(key, *args, &block)
       use_symbol(Faraday::Response, key, *args, &block)
     end
 
-    def adapter(key, *args)
-      block = block_given? ? Proc.new : nil
+    def adapter(key, *args, &block)
       use_symbol(Faraday::Adapter, key, *args, &block)
     end
 
     ## methods to push onto the various positions in the stack:
 
     def insert(index, *args, &block)
+      raise_if_locked
       index = assert_index(index)
       handler = self.class::Handler.new(*args, &block)
       @handlers.insert(index, handler)
@@ -112,20 +125,25 @@ module Faraday
     end
 
     def swap(index, *args, &block)
+      raise_if_locked
       index = assert_index(index)
       @handlers.delete_at(index)
       insert(index, *args, &block)
     end
 
     def delete(handler)
+      raise_if_locked
       @handlers.delete(handler)
     end
 
     private
 
-    def use_symbol(mod, key, *args)
-      block = block_given? ? Proc.new : nil
-      use(mod.lookup_module(key), *args, &block)
+    def raise_if_locked
+      raise StackLocked, "can't modify middleware stack after making a request" if locked?
+    end
+
+    def use_symbol(mod, key, *args, &block)
+      use(mod.lookup_middleware(key), *args, &block)
     end
 
     def assert_index(index)