faraday 0.6.0 → 0.8.0

data/lib/faraday/connection.rb

@@ -1,16 +1,17 @@
-require 'addressable/uri'
+require 'cgi'
 require 'set'
-require 'base64'
+require 'forwardable'
+require 'uri'
+
+Faraday.require_libs 'builder', 'request', 'response', 'utils'
 
 module Faraday
   class Connection
-    include Addressable, Faraday::Utils
-
-    METHODS = Set.new [:get, :post, :put, :delete, :head]
-    METHODS_WITH_BODIES = Set.new [:post, :put]
+    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
@@ -22,90 +23,127 @@ module Faraday
         options = url
         url     = options[:url]
       end
-      @headers          = Headers.new
-      @params           = {}
-      @options          = options[:request] || {}
-      @ssl              = options[:ssl]     || {}
-      @parallel_manager = options[:parallel]
-      self.url_prefix = url if url
-      proxy(options[:proxy])
-      merge_params  @params,  options[:params]  if options[:params]
-      merge_headers @headers, options[:headers] if options[:headers]
-
-      if block_given?
-        @builder = Builder.create { |b| yield b }
-      else
-        @builder = options[:builder] || Builder.new
+      @headers = Utils::Headers.new
+      @params  = Utils::ParamsHash.new
+      @options = options[:request] || {}
+      @ssl     = options[:ssl]     || {}
+
+      @parallel_manager = nil
+      @default_parallel_manager = options[:parallel_manager]
+
+      @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
-    end
 
-    def use(klass, *args, &block)
-      @builder.use(klass, *args, &block)
-    end
+      self.url_prefix = url || 'http:/'
 
-    def request(key, *args, &block)
-      @builder.request(key, *args, &block)
-    end
+      @params.update options[:params]   if options[:params]
+      @headers.update options[:headers] if options[:headers]
 
-    def response(key, *args, &block)
-      @builder.response(key, *args, &block)
+      @proxy = nil
+      proxy(options.fetch(:proxy) { ENV['http_proxy'] })
+
+      yield self if block_given?
     end
 
-    def adapter(key, *args, &block)
-      @builder.adapter(key, *args, &block)
+    # Public: Replace default query parameters.
+    def params=(hash)
+      @params.replace hash
     end
 
-    def build(options = {}, &block)
-      @builder.build(options, &block)
+    # Public: Replace default request headers.
+    def headers=(hash)
+      @headers.replace hash
     end
 
-    def get(url = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:get, url, nil, headers, &block)
+    extend Forwardable
+    def_delegators :builder, :build, :use, :request, :response, :adapter
+
+    # The "rack app" wrapped in middleware. All requests are sent here.
+    #
+    # The builder is responsible for creating the app object. After this,
+    # the builder gets locked to ensure no further modifications are made
+    # to the middleware stack.
+    #
+    # Returns an object that responds to `call` and returns a Response.
+    def app
+      @app ||= begin
+        builder.lock!
+        builder.to_app(lambda { |env|
+          # the inner app that creates and returns the Response object
+          response = Response.new
+          response.finish(env) unless env[:parallel_manager]
+          env[:response] = response
+        })
+      end
     end
 
-    def post(url = nil, body = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:post, url, body, 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 put(url = nil, body = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:put, url, body, 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 head(url = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:head, url, nil, headers, &block)
+    def basic_auth(login, pass)
+      headers[Faraday::Request::Authorization::KEY] =
+        Faraday::Request::BasicAuthentication.header(login, pass)
     end
 
-    def delete(url = nil, headers = nil)
-      block = block_given? ? Proc.new : nil
-      run_request(:delete, url, nil, headers, &block)
+    def token_auth(token, options = nil)
+      headers[Faraday::Request::Authorization::KEY] =
+        Faraday::Request::TokenAuthentication.header(token, options)
     end
 
-    def basic_auth(login, pass)
-      auth = Base64.encode64("#{login}:#{pass}")
-      auth.gsub!("\n", "")
-      @headers['authorization'] = "Basic #{auth}"
+    def authorization(type, token)
+      headers[Faraday::Request::Authorization::KEY] =
+        Faraday::Request::Authorization.header(type, token)
     end
 
-    def token_auth(token, options = {})
-      values = ["token=#{token.to_s.inspect}"]
-      options.each do |key, value|
-        values << "#{key}=#{value.to_s.inspect}"
+    # 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.detect do |h|
+          h.klass.respond_to?(:supports_parallel?) and h.klass.supports_parallel?
+        end
+
+        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
@@ -115,20 +153,29 @@ module Faraday
     def proxy(arg = nil)
       return @proxy if arg.nil?
 
-      @proxy =
-        case arg
-          when String then {:uri => proxy_arg_to_uri(arg)}
-          when URI    then {:uri => arg}
-          when Hash
-            if arg[:uri] = proxy_arg_to_uri(arg[:uri])
-              arg
-            else
-              raise ArgumentError, "no :uri option."
-            end
-        end
+      @proxy = if arg.is_a? Hash
+        uri = arg.fetch(:uri) { raise ArgumentError, "no :uri option" }
+        arg.merge :uri => self.class.URI(uri)
+      else
+        {:uri => self.class.URI(arg)}
+      end
     end
 
-    # Parses the giving url with Addressable::URI and stores the individual
+    # normalize URI() behavior across Ruby versions
+    def self.URI(url)
+      if url.respond_to?(:host)
+        url
+      elsif url.respond_to?(:to_str)
+        Kernel.URI(url)
+      else
+        raise ArgumentError, "bad argument (expected URI object or URI string)"
+      end
+    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.
     #
@@ -140,26 +187,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
-      if uri.query && !uri.query.empty?
-        merge_params @params, parse_query(uri.query)
-      end
+
+      params.merge_query(uri.query)
+      uri.query = nil
+
       if uri.user && uri.password
-        basic_auth(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)
@@ -167,12 +215,27 @@ module Faraday
         raise ArgumentError, "unknown http method: #{method}"
       end
 
-      Request.run(self, 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
         yield req if block_given?
       end
+
+      env = request.to_env(self)
+      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
@@ -186,39 +249,38 @@ module Faraday
     #   conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
     #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
     #
-    def build_url(url, params = nil)
-      uri          = URI.parse(url.to_s)
-      if @path_prefix && uri.path !~ /^\//
-        uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
-      end
-      uri.host   ||= @host
-      uri.port   ||= @port
-      uri.scheme ||= @scheme
-      replace_query(uri, params)
-      uri
-    end
+    def build_url(url, extra_params = nil)
+      uri = build_exclusive_url(url)
 
-    def dup
-      self.class.new(build_url(''), :headers => headers.dup, :params => params.dup, :builder => builder.dup)
+      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
+
+      uri
     end
 
-    def replace_query(uri, params)
-      url_params = @params.dup
-      if uri.query && !uri.query.empty?
-        merge_params(url_params, parse_query(uri.query))
-      end
-      if params && !params.empty?
-        merge_params(url_params, params)
+    # 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.query = url_params.empty? ? nil : build_query(url_params)
+      uri = url ? base + url : base
+      uri.query = params.to_query if params
+      uri.query = nil if uri.query and uri.query.empty?
       uri
     end
 
-    def proxy_arg_to_uri(arg)
-      case arg
-        when String then URI.parse(arg)
-        when URI    then arg
-      end
+    def dup
+      self.class.new(build_url(''), :headers => headers.dup, :params => params.dup, :builder => builder.dup, :ssl => ssl.dup)
     end
   end
 end

data/lib/faraday/error.rb

@@ -3,9 +3,9 @@ module Faraday
     class ClientError < StandardError
       attr_reader :response
 
-      def initialize(ex)
+      def initialize(ex, response = nil)
         @wrapped_exception = nil
-        @response = nil
+        @response = response
 
         if ex.respond_to?(:backtrace)
           super(ex.message)
@@ -34,5 +34,7 @@ module Faraday
     class ConnectionFailed < ClientError;   end
     class ResourceNotFound < ClientError;   end
     class ParsingError     < ClientError;   end
+    class TimeoutError < ClientError; end
+    class MissingDependency < StandardError; end
   end
 end

data/lib/faraday/middleware.rb

@@ -1,16 +1,14 @@
 module Faraday
   class Middleware
-    class << self
-      attr_accessor :load_error, :supports_parallel_requests
-      alias supports_parallel_requests? supports_parallel_requests
+    extend MiddlewareRegistry
 
-      # valid parallel managers should respond to #run with no parameters.
-      # otherwise, return a short wrapper around it.
-      def setup_parallel_manager(options = {})
-        nil
-      end
+    class << self
+      attr_accessor :load_error
+      private :load_error=
     end
 
+    self.load_error = nil
+
     # Executes a block which should try to require and reference dependent libraries
     def self.dependency(lib = nil)
       lib ? require(lib) : yield
@@ -18,12 +16,22 @@ module Faraday
       self.load_error = error
     end
 
+    def self.new(*)
+      raise "missing dependency for #{self}: #{load_error.message}" unless loaded?
+      super
+    end
+
     def self.loaded?
-      @load_error.nil?
+      load_error.nil?
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.send(:load_error=, self.load_error)
     end
 
     def initialize(app = nil)
       @app = app
     end
   end
-end
+end

data/lib/faraday/request/authorization.rb

@@ -0,0 +1,40 @@
+module Faraday
+  class Request::Authorization < Faraday::Middleware
+    KEY = "Authorization".freeze
+
+    # Public
+    def self.header(type, token)
+      case token
+      when String, Symbol then "#{type} #{token}"
+      when Hash then build_hash(type.to_s, token)
+      else
+        raise ArgumentError, "Can't build an Authorization #{type} header from #{token.inspect}"
+      end
+    end
+
+    # Internal
+    def self.build_hash(type, hash)
+      offset = KEY.size + type.size + 3
+      comma = ",\n#{' ' * offset}"
+      values = []
+      hash.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
+      end
+      "#{type} #{values * comma}"
+    end
+
+    def initialize(app, type, token)
+      @header_value = self.class.header(type, token)
+      super(app)
+    end
+
+    # Public
+    def call(env)
+      unless env[:request_headers][KEY]
+        env[:request_headers][KEY] = @header_value
+      end
+      @app.call(env)
+    end
+  end
+end
+

data/lib/faraday/request/basic_authentication.rb

@@ -0,0 +1,13 @@
+require 'base64'
+
+module Faraday
+  class Request::BasicAuthentication < Request::Authorization
+    # Public
+    def self.header(login, pass)
+      value = Base64.encode64([login, pass].join(':'))
+      value.gsub!("\n", '')
+      super(:Basic, value)
+    end
+  end
+end
+

data/lib/faraday/request/multipart.rb

@@ -21,12 +21,11 @@ module Faraday
       )
     end
 
-    def has_multipart?(body)
-      body.values.each do |val|
-        if val.respond_to?(:content_type)
-          return true
-        elsif val.respond_to?(:values)
-          return true if has_multipart?(val)
+    def has_multipart?(obj)
+      # string is an enum in 1.8, returning list of itself
+      if obj.respond_to?(:each) && !obj.is_a?(String)
+        (obj.respond_to?(:values) ? obj.values : obj).each do |val|
+          return true if (val.respond_to?(:content_type) || has_multipart?(val))
         end
       end
       false

data/lib/faraday/request/retry.rb

@@ -0,0 +1,21 @@
+module Faraday
+  class Request::Retry < Faraday::Middleware
+    def initialize(app, retries = 2)
+      @retries = retries
+      super(app)
+    end
+
+    def call(env)
+      retries = @retries
+      begin
+        @app.call(env)
+      rescue StandardError, Timeout::Error
+        if retries > 0
+          retries -= 1
+          retry
+        end
+        raise
+      end
+    end
+  end
+end

data/lib/faraday/request/token_authentication.rb

@@ -0,0 +1,15 @@
+module Faraday
+  class Request::TokenAuthentication < Request::Authorization
+    # Public
+    def self.header(token, options = nil)
+      options ||= {}
+      options[:token] = token
+      super :Token, options
+    end
+
+    def initialize(app, token, options = nil)
+      super(app, token, options)
+    end
+  end
+end
+

data/lib/faraday/request/url_encoded.rb

@@ -13,10 +13,8 @@ module Faraday
       end
       @app.call env
     end
-    
+
     def match_content_type(env)
-      type = request_type(env)
-      
       if process_request?(env)
         env[:request_headers][CONTENT_TYPE] ||= self.class.mime_type
         yield env[:body] unless env[:body].respond_to?(:to_str)