faraday 0.7.6 → 0.8.0.rc2

data/lib/faraday/adapter/em_synchrony.rb

@@ -1,11 +1,21 @@
+require 'uri'
+
 module Faraday
   class Adapter
     class EMSynchrony < Faraday::Adapter
+
       dependency do
         require 'em-synchrony/em-http'
+        require 'em-synchrony/em-multi'
         require 'fiber'
       end
 
+      self.supports_parallel = true
+
+      def self.setup_parallel_manager(options = {})
+        ParallelManager.new
+      end
+
       def call(env)
         super
         request = EventMachine::HttpRequest.new(URI::parse(env[:url].to_s))
@@ -22,10 +32,10 @@ module Faraday
 
         if req = env[:request]
           if proxy = req[:proxy]
-            uri = Addressable::URI.parse(proxy[:uri])
+            uri = URI.parse(proxy[:uri])
             options[:proxy] = {
               :host => uri.host,
-              :port => uri.inferred_port
+              :port => uri.port
             }
             if proxy[:username] && proxy[:password]
               options[:proxy][:authorization] = [proxy[:username], proxy[:password]]
@@ -38,22 +48,41 @@ module Faraday
           end
         end
 
-        client = nil
-        block = lambda { request.send env[:method].to_s.downcase.to_sym, options }
-        if !EM.reactor_running?
-          EM.run {
-            Fiber.new do
-              client = block.call
-              EM.stop
-            end.resume
-          }
+        http_method = env[:method].to_s.downcase.to_sym
+
+        # Queue requests for parallel execution.
+        if env[:parallel_manager]
+          env[:parallel_manager].add(request, http_method, options) do |resp|
+            save_response(env, resp.response_header.status, resp.response) do |resp_headers|
+              resp.response_header.each do |name, value|
+                resp_headers[name.to_sym] = value
+              end
+            end
+
+            # Finalize the response object with values from `env`.
+            env[:response].finish(env)
+          end
+
+        # Execute single request.
         else
-          client = block.call
-        end
+          client = nil
+          block = lambda { request.send(http_method, options) }
 
-        save_response(env, client.response_header.status, client.response) do |response_headers|
-          client.response_header.each do |name, value|
-            response_headers[name.to_sym] = value
+          if !EM.reactor_running?
+            EM.run do
+              Fiber.new {
+                client = block.call
+                EM.stop
+              }.resume
+            end
+          else
+            client = block.call
+          end
+
+          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
+            end
           end
         end
 
@@ -64,3 +93,24 @@ module Faraday
     end
   end
 end
+
+require 'faraday/adapter/em_synchrony/parallel_manager'
+
+# add missing patch(), options() methods
+EventMachine::HTTPMethods.module_eval do
+  ([:patch, :options] - instance_methods).each do |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

data/lib/faraday/adapter/em_synchrony/parallel_manager.rb

@@ -0,0 +1,66 @@
+module Faraday
+  class Adapter
+    class EMSynchrony < Faraday::Adapter
+      class ParallelManager
+
+        # Add requests to queue. The `request` argument should be a
+        # `EM::HttpRequest` object.
+        def add(request, method, *args, &block)
+          queue << {
+            :request => request,
+            :method => method,
+            :args => args,
+            :block => block
+          }
+        end
+
+        # Run all requests on queue with `EM::Synchrony::Multi`, wrapping
+        # it in a reactor and fiber if needed.
+        def run
+          result = nil
+          if !EM.reactor_running?
+            EM.run {
+              Fiber.new do
+                result = perform
+                EM.stop
+              end.resume
+            }
+          else
+            result = perform
+          end
+          result
+        end
+
+
+        private
+
+        # The request queue.
+        def queue
+          @queue ||= []
+        end
+
+        # Main `EM::Synchrony::Multi` performer.
+        def perform
+          multi = ::EM::Synchrony::Multi.new
+
+          queue.each do |item|
+            method = "a#{item[:method]}".to_sym
+
+            req = item[:request].send(method, *item[:args])
+            req.callback(&item[:block])
+
+            req_name = "req_#{multi.requests.size}".to_sym
+            multi.add(req_name, req)
+          end
+
+          # Clear the queue, so parallel manager objects can be reused.
+          @queue = []
+
+          # Block fiber until all requests have returned.
+          multi.perform
+        end
+
+      end # ParallelManager
+    end # EMSynchrony
+  end # Adapter
+end # Faraday

data/lib/faraday/adapter/net_http.rb

@@ -13,7 +13,7 @@ module Faraday
         url = env[:url]
         req = env[:request]
 
-        http = net_http_class(env).new(url.host, url.inferred_port)
+        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

data/lib/faraday/adapter/test.rb

@@ -14,8 +14,6 @@ module Faraday
     class Test < Faraday::Adapter
       attr_accessor :stubs
 
-      def self.loaded?() false end
-
       class Stubs
         class NotFound < StandardError
         end
@@ -34,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)
@@ -87,19 +86,27 @@ 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, :params, :body, :block)
         def initialize(full, body, block)
           path, query = full.split('?')
           params = query ?
-            Rack::Utils.parse_nested_query(query) :
+            Faraday::Utils.parse_nested_query(query) :
             {}
           super path, params, body, block
         end
@@ -107,7 +114,7 @@ module Faraday
         def matches?(request_uri, request_body)
           request_path, request_query = request_uri.split('?')
           request_params = request_query ?
-            Rack::Utils.parse_nested_query(request_query) :
+            Faraday::Utils.parse_nested_query(request_query) :
             {}
           request_path == path &&
             params_match?(request_params) &&
@@ -141,7 +148,7 @@ module Faraday
 
         if stub = stubs.match(env[:method], normalized_path, env[:body])
           env[:params] = (query = env[:url].query) ?
-            Rack::Utils.parse_nested_query(query)  :
+            Faraday::Utils.parse_nested_query(query)  :
             {}
           status, headers, body = stub.block.call(env)
           save_response(env, status, body, headers)

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,53 +11,88 @@ 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))
 
-        if ssl = env[:ssl]
-          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
+        configure_ssl     req, env
+        configure_proxy   req, env
+        configure_timeout req, env
 
-        env_req = env[:request]
-
-        if proxy = env_req[:proxy]
-          req.proxy = "#{proxy[:uri].host}:#{proxy[:uri].port}"
-
-          if proxy[:username] && proxy[:password]
-            req.proxy_username = proxy[:username]
-            req.proxy_password = proxy[:password]
+        req.on_complete do |resp|
+          if resp.timed_out?
+            if parallel?(env)
+              # TODO: error callback in async mode
+            else
+              raise Faraday::Error::TimeoutError, "request timed out"
+            end
           end
-        end
 
-        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]
-
-        is_parallel = !!env[:parallel_manager]
-        req.on_complete do |resp|
           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 is_parallel
+          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_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/builder.rb

@@ -8,10 +8,6 @@ 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
 
@@ -91,24 +87,24 @@ module Faraday
       @handlers.frozen?
     end
 
-    def use(klass, *args)
-      raise_if_locked
-      block = block_given? ? Proc.new : nil
-      @handlers << self.class::Handler.new(klass, *args, &block)
+    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
 
@@ -146,9 +142,8 @@ module Faraday
       raise StackLocked, "can't modify middleware stack after making a request" if locked?
     end
 
-    def use_symbol(mod, key, *args)
-      block = block_given? ? Proc.new : nil
-      use(mod.lookup_module(key), *args, &block)
+    def use_symbol(mod, key, *args, &block)
+      use(mod.lookup_middleware(key), *args, &block)
     end
 
     def assert_index(index)

data/lib/faraday/connection.rb

@@ -1,21 +1,18 @@
-require 'addressable/uri'
 require 'base64'
 require 'cgi'
 require 'set'
-require 'faraday/builder'
-require 'faraday/request'
-require 'faraday/response'
-require 'faraday/utils'
+require 'forwardable'
+require 'uri'
+
+Faraday.require_libs 'builder', 'request', 'response', 'utils'
 
 module Faraday
   class Connection
-    include Addressable
-
     METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
     METHODS_WITH_BODIES = Set.new [:post, :put, :patch, :options]
 
-    attr_accessor :host, :port, :scheme, :params, :headers, :parallel_manager
-    attr_reader   :path_prefix, :builder, :options, :ssl
+    attr_reader   :params, :headers, :url_prefix, :builder, :options, :ssl, :parallel_manager
+    attr_writer   :default_parallel_manager
 
     # :url
     # :params
@@ -27,47 +24,43 @@ module Faraday
         options = url
         url     = options[:url]
       end
-      @headers          = Utils::Headers.new
-      @params           = Utils::ParamsHash.new
-      @options          = options[:request] || {}
-      @ssl              = options[:ssl]     || {}
-      @parallel_manager = options[:parallel]
+      @headers = Utils::Headers.new
+      @params  = Utils::ParamsHash.new
+      @options = options[:request] || {}
+      @ssl     = options[:ssl]     || {}
+
+      @parallel_manager = nil
+      @default_parallel_manager = options[:parallel_manager]
 
-      @path_prefix = @host = @port = @scheme = nil
-      self.url_prefix = url if url
+      @builder = options[:builder] || begin
+        # pass an empty block to Builder so it doesn't assume default middleware
+        block = block_given?? Proc.new {|b| } : nil
+        Builder.new(&block)
+      end
 
-      @proxy = nil
-      proxy(options[:proxy])
+      self.url_prefix = url || 'http:/'
 
       @params.update options[:params]   if options[:params]
       @headers.update options[:headers] if options[:headers]
 
-      if block_given?
-        @builder = Builder.create { |b| yield b }
-      else
-        @builder = options[:builder] || Builder.new
-      end
-    end
-
-    def use(klass, *args, &block)
-      @builder.use(klass, *args, &block)
-    end
+      @proxy = nil
+      proxy(options.fetch(:proxy) { ENV['http_proxy'] })
 
-    def request(key, *args, &block)
-      @builder.request(key, *args, &block)
+      yield self if block_given?
     end
 
-    def response(key, *args, &block)
-      @builder.response(key, *args, &block)
+    # Public: Replace default query parameters.
+    def params=(hash)
+      @params.replace hash
     end
 
-    def adapter(key, *args, &block)
-      @builder.adapter(key, *args, &block)
+    # Public: Replace default request headers.
+    def headers=(hash)
+      @headers.replace hash
     end
 
-    def build(options = {}, &block)
-      @builder.build(options, &block)
-    end
+    extend Forwardable
+    def_delegators :builder, :build, :use, :request, :response, :adapter
 
     # The "rack app" wrapped in middleware. All requests are sent here.
     #
@@ -88,58 +81,62 @@ module Faraday
       end
     end
 
-    def get(url = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:get, url, nil, headers, &block)
-    end
-
-    def post(url = nil, body = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:post, url, body, headers, &block)
-    end
-
-    def put(url = nil, body = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:put, url, body, headers, &block)
-    end
-
-    def patch(url = nil, body = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:patch, url, body, headers, &block)
-    end
-
-    def head(url = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:head, url, nil, headers, &block)
+    # get/head/delete(url, params, headers)
+    %w[get head delete].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(url = nil, params = nil, headers = nil)
+          run_request(:#{method}, url, nil, headers) { |request|
+            request.params.update(params) if params
+            yield request if block_given?
+          }
+        end
+      RUBY
     end
 
-    def delete(url = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:delete, url, nil, headers, &block)
+    # post/put/patch(url, body, headers)
+    %w[post put patch].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(url = nil, body = nil, headers = nil, &block)
+          run_request(:#{method}, url, body, headers, &block)
+        end
+      RUBY
     end
 
     def basic_auth(login, pass)
-      auth = Base64.encode64("#{login}:#{pass}")
-      auth.gsub!("\n", "")
-      @headers['authorization'] = "Basic #{auth}"
+      @builder.insert(0, Faraday::Request::BasicAuthentication, login, pass)
     end
 
     def token_auth(token, options = {})
-      values = ["token=#{token.to_s.inspect}"]
-      options.each do |key, value|
-        values << "#{key}=#{value.to_s.inspect}"
+      @builder.insert(0, Faraday::Request::TokenAuthentication, token, options)
+    end
+
+    # Internal: Traverse the middleware stack in search of a
+    # parallel-capable adapter.
+    #
+    # Yields in case of not found.
+    #
+    # Returns a parallel manager or nil if not found.
+    def default_parallel_manager
+      @default_parallel_manager ||= begin
+        handler = @builder.handlers.find { |h|
+          h.klass.respond_to?(:supports_parallel?) and h.klass.supports_parallel?
+        }
+        if handler then handler.klass.setup_parallel_manager
+        elsif block_given? then yield
+        end
       end
-      # 21 = "Authorization: Token ".size
-      comma = ",\n#{' ' * 21}"
-      @headers['authorization'] = "Token #{values * comma}"
     end
 
     def in_parallel?
       !!@parallel_manager
     end
 
-    def in_parallel(manager)
-      @parallel_manager = manager
+    def in_parallel(manager = nil)
+      @parallel_manager = manager || default_parallel_manager {
+        warn "Warning: `in_parallel` called but no parallel-capable adapter on Faraday stack"
+        warn caller[2,10].join("\n")
+        nil
+      }
       yield
       @parallel_manager && @parallel_manager.run
     ensure
@@ -151,15 +148,23 @@ module Faraday
 
       @proxy = if arg.is_a? Hash
         uri = arg.fetch(:uri) { raise ArgumentError, "no :uri option" }
-        arg.merge :uri => URI.parse(uri)
+        arg.merge :uri => self.class.URI(uri)
       else
-        {:uri => URI.parse(arg)}
+        {:uri => self.class.URI(arg)}
       end
-    rescue TypeError
-      raise ArgumentError, "bad uri"
     end
 
-    # Parses the giving url with Addressable::URI and stores the individual
+    # normalize URI() behavior across Ruby versions
+    def self.URI url
+      url.respond_to?(:host) ? url :
+        url.respond_to?(:to_str) ? Kernel.URI(url) :
+          raise(ArgumentError, "bad argument (expected URI object or URI string)")
+    end
+
+    def_delegators :url_prefix, :scheme, :scheme=, :host, :host=, :port, :port=
+    def_delegator :url_prefix, :path, :path_prefix
+
+    # Parses the giving url with URI and stores the individual
     # components in this connection.  These components serve as defaults for
     # requests made by this connection.
     #
@@ -171,27 +176,27 @@ module Faraday
     #   conn.get("nigiri?page=2") # accesses https://sushi.com/api/nigiri
     #
     def url_prefix=(url)
-      uri              = URI.parse(url)
-      self.scheme      = uri.scheme
-      self.host        = uri.host
-      self.port        = uri.port
+      uri = @url_prefix = self.class.URI(url)
       self.path_prefix = uri.path
 
-      @params.merge_query(uri.query)
+      params.merge_query(uri.query)
+      uri.query = nil
+
       if uri.user && uri.password
         basic_auth(CGI.unescape(uri.user), CGI.unescape(uri.password))
+        uri.user = uri.password = nil
       end
 
       uri
     end
 
-    # Ensures that the path prefix always has a leading / and no trailing /
+    # Ensures that the path prefix always has a leading but no trailing slash
     def path_prefix=(value)
-      if value
-        value.chomp!  "/"
-        value.replace "/#{value}" if value !~ /^\//
+      url_prefix.path = if value
+        value = value.chomp '/'
+        value = '/' + value unless value[0,1] == '/'
+        value
       end
-      @path_prefix = value
     end
 
     def run_request(method, url, body, headers)
@@ -199,7 +204,7 @@ module Faraday
         raise ArgumentError, "unknown http method: #{method}"
       end
 
-      request = Request.create(method) do |req|
+      request = build_request(method) do |req|
         req.url(url)                if url
         req.headers.update(headers) if headers
         req.body = body             if body
@@ -210,6 +215,18 @@ module Faraday
       self.app.call(env)
     end
 
+    # Internal: Creates and configures the request object.
+    #
+    # Returns the new Request.
+    def build_request(method)
+      Request.create(method) do |req|
+        req.params  = self.params.dup
+        req.headers = self.headers.dup
+        req.options = self.options.merge(:proxy => self.proxy)
+        yield req if block_given?
+      end
+    end
+
     # Takes a relative url for a request and combines it with the defaults
     # set on the connection instance.
     #
@@ -222,20 +239,32 @@ module Faraday
     #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
     #
     def build_url(url, extra_params = nil)
-      uri          = URI.parse(url.to_s)
-      if @path_prefix && uri.path !~ /^\//
-        new_path = @path_prefix.size > 1 ? @path_prefix.dup : ''
-        new_path << "/#{uri.path}" unless uri.path.empty?
-        uri.path = new_path
-      end
-      uri.host   ||= @host
-      uri.port   ||= @port
-      uri.scheme ||= @scheme
+      uri = build_exclusive_url(url)
+
+      query_values = self.params.dup.merge_query(uri.query)
+      query_values.update extra_params if extra_params
+      uri.query = query_values.empty? ? nil : query_values.to_query
 
-      params = @params.dup.merge_query(uri.query)
-      params.update extra_params if extra_params
-      uri.query = params.empty? ? nil : params.to_query
+      uri
+    end
 
+    # Internal: Build an absolute URL based on url_prefix.
+    #
+    # url    - A String or URI-like object
+    # params - A Faraday::Utils::ParamsHash to replace the query values
+    #          of the resulting url (default: nil).
+    #
+    # Returns the resulting URI instance.
+    def build_exclusive_url(url, params = nil)
+      url = nil if url.respond_to?(:empty?) and url.empty?
+      base = url_prefix
+      if url and base.path and base.path !~ /\/$/
+        base = base.dup
+        base.path = base.path + '/'  # ensure trailing slash
+      end
+      uri = url ? base + url : base
+      uri.query = params.to_query if params
+      uri.query = nil if uri.query and uri.query.empty?
       uri
     end