faraday 0.6.0 → 0.8.0

data/lib/faraday/request.rb

@@ -9,34 +9,59 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
-  class Request < Struct.new(:path, :params, :headers, :body)
+  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
     extend AutoloadHelper
+    extend MiddlewareRegistry
 
     autoload_all 'faraday/request',
-      :JSON       => 'json',
       :UrlEncoded => 'url_encoded',
-      :Multipart  => 'multipart'
+      :Multipart => 'multipart',
+      :Retry => 'retry',
+      :Timeout => 'timeout',
+      :Authorization => 'authorization',
+      :BasicAuthentication => 'basic_authentication',
+      :TokenAuthentication => 'token_authentication'
 
-    register_lookup_modules \
-      :json        => :JSON,
+    register_middleware \
       :url_encoded => :UrlEncoded,
-      :multipart   => :Multipart
+      :multipart => :Multipart,
+      :retry => :Retry,
+      :authorization => :Authorization,
+      :basic_auth => :BasicAuthentication,
+      :token_auth => :TokenAuthentication
 
-    def self.run(connection, request_method)
-      req = create
-      yield req if block_given?
-      req.run(connection, request_method)
+    def self.create(request_method)
+      new(request_method).tap do |request|
+        yield request if block_given?
+      end
     end
 
-    def self.create
-      req = new(nil, {}, {}, nil)
-      yield req if block_given?
-      req
+    # Public: Replace params, preserving the existing hash type
+    def params=(hash)
+      if params then params.replace hash
+      else super
+      end
     end
 
-    def url(path, params = {})
-      self.path   = path
-      self.params = params
+    # Public: Replace request headers, preserving the existing hash type
+    def headers=(hash)
+      if headers then headers.replace hash
+      else super
+      end
+    end
+
+    def url(path, params = nil)
+      if path.respond_to? :query
+        if query = path.query
+          path = path.dup
+          path.query = nil
+        end
+      else
+        path, query = path.split('?', 2)
+      end
+      self.path = path
+      self.params.merge_query query
+      self.params.update(params) if params
     end
 
     def [](key)
@@ -50,7 +75,7 @@ module Faraday
     # ENV Keys
     # :method - a symbolized request method (:get, :post)
     # :body   - the request body that will eventually be converted to a string.
-    # :url    - Addressable::URI instance of the URI for the current request.
+    # :url    - URI instance for the current request.
     # :status           - HTTP response status code
     # :request_headers  - hash of HTTP Headers to be sent to the server
     # :response_headers - Hash of HTTP headers from the server
@@ -63,29 +88,14 @@ module Faraday
     #     :user       - Proxy server username
     #     :password   - Proxy server password
     # :ssl - Hash of options for configuring SSL requests.
-    def to_env_hash(connection, request_method)
-      env_headers = connection.headers.dup
-      env_params  = connection.params.dup
-      connection.merge_headers(env_headers, headers)
-      connection.merge_params(env_params,  params)
-
-      { :method           => request_method,
+    def to_env(connection)
+      { :method           => method,
         :body             => body,
-        :url              => connection.build_url(path, env_params),
-        :request_headers  => env_headers,
+        :url              => connection.build_exclusive_url(path, params),
+        :request_headers  => headers,
         :parallel_manager => connection.parallel_manager,
-        :request          => connection.options.merge(:proxy => connection.proxy),
+        :request          => options,
         :ssl              => connection.ssl}
     end
-
-    def run(connection, request_method)
-      app = lambda { |env|
-        response = Response.new
-        response.finish(env) unless env[:parallel_manager]
-        env[:response] = response
-      }
-      env = to_env_hash(connection, request_method)
-      connection.builder.to_app(app).call(env)
-    end
   end
 end

data/lib/faraday/response/raise_error.rb

@@ -8,7 +8,7 @@ module Faraday
         raise Faraday::Error::ClientError, response_values(env)
       end
     end
-    
+
     def response_values(env)
       {:status => env[:status], :headers => env[:response_headers], :body => env[:body]}
     end

data/lib/faraday/response.rb

@@ -5,8 +5,8 @@ module Faraday
     # Used for simple response middleware.
     class Middleware < Faraday::Middleware
       def call(env)
-        @app.call(env).on_complete do |env|
-          on_complete(env)
+        @app.call(env).on_complete do |environment|
+          on_complete(environment)
         end
       end
 
@@ -14,19 +14,20 @@ module Faraday
       # Calls the `parse` method if defined
       def on_complete(env)
         if respond_to? :parse
-          env[:body] = parse(env[:body])
+          env[:body] = parse(env[:body]) unless [204,304].index env[:status]
         end
       end
     end
 
     extend Forwardable
     extend AutoloadHelper
+    extend MiddlewareRegistry
 
     autoload_all 'faraday/response',
       :RaiseError => 'raise_error',
       :Logger     => 'logger'
 
-    register_lookup_modules \
+    register_middleware \
       :raise_error => :RaiseError,
       :logger      => :Logger
 
@@ -72,7 +73,7 @@ module Faraday
     end
 
     def success?
-      status == 200
+      (200..299).include?(status)
     end
 
     # because @on_complete_callbacks cannot be marshalled

data/lib/faraday/upload_io.rb

@@ -10,7 +10,7 @@ end
 module Faraday
   class CompositeReadIO < ::CompositeReadIO
     attr_reader :length
-    
+
     def initialize(parts)
       @length = parts.inject(0) { |sum, part| sum + part.length }
       ios = parts.map{ |part| part.to_io }

data/lib/faraday/utils.rb

@@ -1,12 +1,17 @@
-require 'rack/utils'
+require 'cgi'
+
 module Faraday
   module Utils
-    include Rack::Utils
-
-    extend Rack::Utils
     extend self
 
-    class Headers < HeaderHash
+    # Adapted from Rack::Utils::HeaderHash
+    class Headers < ::Hash
+      def initialize(hash={})
+        super()
+        @names = {}
+        self.update hash
+      end
+
       # symbol -> string mapper + cache
       KeyMap = Hash.new do |map, key|
         map[key] = if key.respond_to?(:to_str) then key
@@ -17,24 +22,60 @@ module Faraday
         end
       end
       KeyMap[:etag] = "ETag"
-      
+
       def [](k)
-        super(KeyMap[k])
+        k = KeyMap[k]
+        super(k) || super(@names[k.downcase])
       end
 
       def []=(k, v)
+        k = KeyMap[k]
+        k = (@names[k.downcase] ||= k)
         # join multiple values with a comma
         v = v.to_ary.join(', ') if v.respond_to? :to_ary
-        super(KeyMap[k], v)
+        super k, v
+      end
+
+      def delete(k)
+        k = KeyMap[k]
+        if k = @names[k.downcase]
+          @names.delete k.downcase
+          super k
+        end
+      end
+
+      def include?(k)
+        @names.include? k.downcase
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def merge!(other)
+        other.each { |k, v| self[k] = v }
+        self
       end
-      
       alias_method :update, :merge!
-      
+
+      def merge(other)
+        hash = dup
+        hash.merge! other
+      end
+
+      def replace(other)
+        clear
+        self.update other
+        self
+      end
+
+      def to_hash() ::Hash.new.update(self) end
+
       def parse(header_string)
         return unless header_string && !header_string.empty?
         header_string.split(/\r\n/).
           tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
-          map  { |h| h.split(/:\s+/, 2) }.reject { |(k, v)| k.nil? }. # split key and value, ignore blank lines
+          map  { |h| h.split(/:\s+/, 2) }.reject { |p| p[0].nil? }. # split key and value, ignore blank lines
           each { |key, value|
             # join multiple values with a comma
             if self[key] then self[key] << ', ' << value
@@ -44,17 +85,82 @@ module Faraday
       end
     end
 
-    # Make Rack::Utils build_query method public.
-    public :build_query
+    # hash with stringified keys
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def include?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query)
+        if query && !query.empty?
+          update Utils.parse_query(query)
+        end
+        self
+      end
+
+      def to_query
+        Utils.build_nested_query(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+
+    # Copied from Rack
+    def build_query(params)
+      params.map { |k, v|
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
+        end
+      }.join("&")
+    end
 
-    # Override Rack's version since it doesn't handle non-String values
+    # Rack's version modified to handle non-String values
     def build_nested_query(value, prefix = nil)
       case value
       when Array
-        value.map { |v| build_nested_query(v, "#{prefix}[]") }.join("&")
+        value.map { |v| build_nested_query(v, "#{prefix}%5B%5D") }.join("&")
       when Hash
         value.map { |k, v|
-          build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          build_nested_query(v, prefix ? "#{prefix}%5B#{escape(k)}%5D" : escape(k))
         }.join("&")
       when NilClass
         prefix
@@ -64,26 +170,70 @@ module Faraday
       end
     end
 
-    # Be sure to URI escape '+' symbols to %2B. Otherwise, they get interpreted
-    # as spaces.
-    def escape(s)
-      s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) do
-        '%' << $1.unpack('H2'*bytesize($1)).join('%').tap { |c| c.upcase! }
+    def escape(s) CGI.escape s.to_s end
+
+    def unescape(s) CGI.unescape s.to_s end
+
+    DEFAULT_SEP = /[&;] */n
+
+    # Adapted from Rack
+    def parse_query(qs)
+      params = {}
+
+      (qs || '').split(DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |x| unescape(x) }
+
+        if cur = params[k]
+          if cur.class == Array then params[k] << v
+          else params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
       end
+      params
     end
 
-    # Turns param keys into strings
-    def merge_params(existing_params, new_params)
-      new_params.each do |key, value|
-        existing_params[key.to_s] = value
+    def parse_nested_query(qs)
+      params = {}
+
+      (qs || '').split(DEFAULT_SEP).each do |p|
+        k, v = p.split('=', 2).map { |s| unescape(s) }
+        normalize_params(params, k, v)
       end
+      params
     end
 
-    # Turns headers keys and values into strings
-    def merge_headers(existing_headers, new_headers)
-      new_headers.each do |key, value|
-        existing_headers[key] = value.to_s
+    # Stolen from Rack
+    def normalize_params(params, name, v = nil)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
+
+      return if k.empty?
+
+      if after == ""
+        params[k] = v
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        params[k] << v
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
+      else
+        params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
+        params[k] = normalize_params(params[k], after, v)
       end
+
+      return params
     end
 
     # Receives a URL and returns just the path with the query string sorted.
@@ -92,6 +242,23 @@ module Faraday
       (url.query ? "?#{sort_query_params(url.query)}" : "")
     end
 
+    # Recursive hash update
+    def deep_merge!(target, hash)
+      hash.each do |key, value|
+        if Hash === value and Hash === target[key]
+          target[key] = deep_merge(target[key], value)
+        else
+          target[key] = value
+        end
+      end
+      target
+    end
+
+    # Recursive hash merge
+    def deep_merge(source, hash)
+      deep_merge!(source.dup, hash)
+    end
+
     protected
 
     def sort_query_params(query)

data/lib/faraday.rb

@@ -1,7 +1,8 @@
 module Faraday
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 
   class << self
+    attr_accessor :root_path, :lib_path
     attr_accessor :default_adapter
     attr_writer   :default_connection
 
@@ -10,29 +11,63 @@ module Faraday
       Faraday::Connection.new(url, options, &block)
     end
 
+    def require_libs(*libs)
+      libs.each do |lib|
+        require "#{lib_path}/#{lib}"
+      end
+    end
+
+    alias require_lib require_libs
+
   private
     def method_missing(name, *args, &block)
       default_connection.send(name, *args, &block)
     end
   end
 
+  self.root_path = File.expand_path "..", __FILE__
+  self.lib_path = File.expand_path "../faraday", __FILE__
   self.default_adapter = :net_http
 
   def self.default_connection
     @default_connection ||= Connection.new
   end
 
-  module AutoloadHelper
-    def register_lookup_modules(mods)
-      (@lookup_module_index ||= {}).update(mods)
+  begin
+    require RUBY_VERSION < '1.9' ? 'system_timer' : 'timeout'
+  rescue LoadError
+    require 'timeout'
+    warn "Faraday: you may want to install system_timer for reliable timeouts"
+  ensure
+    Timer = defined?(::SystemTimer) ? ::SystemTimer : ::Timeout
+  end
+
+  module MiddlewareRegistry
+    # Internal: Register middleware class(es) on the current module.
+    #
+    # mapping - A Hash mapping Symbol keys to classes. See
+    #           Faraday.register_middleware for more details.
+    def register_middleware(mapping)
+      (@registered_middleware ||= {}).update(mapping)
     end
 
-    def lookup_module(key)
-      return if !@lookup_module_index
-      const_get @lookup_module_index[key] || key
+    # Internal: Lookup middleware class with a registered Symbol shortcut.
+    #
+    # Returns a middleware Class.
+    def lookup_middleware(key)
+      unless defined? @registered_middleware and found = @registered_middleware[key]
+        raise "#{key.inspect} is not registered on #{self}"
+      end
+      found = @registered_middleware[key] = found.call if found.is_a? Proc
+      found.is_a?(Module) ? found : const_get(found)
     end
+  end
 
+  module AutoloadHelper
     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
@@ -54,7 +89,30 @@ module Faraday
 
   extend AutoloadHelper
 
-  autoload_all 'faraday',
+  # Public: register middleware classes under a short name.
+  #
+  # type    - A Symbol specifying the kind of middleware (default: :middleware)
+  # mapping - A Hash mapping Symbol keys to classes. Classes can be expressed
+  #           as fully qualified constant, or a Proc that will be lazily called
+  #           to return the former.
+  #
+  # Examples
+  #
+  #   Faraday.register_middleware :aloha => MyModule::Aloha
+  #   Faraday.register_middleware :response, :boom => MyModule::Boom
+  #
+  #   # shortcuts are now available in Builder:
+  #   builder.use :aloha
+  #   builder.response :boom
+  #
+  # Returns nothing.
+  def self.register_middleware type, mapping = nil
+    type, mapping = :middleware, type if mapping.nil?
+    component = self.const_get(type.to_s.capitalize)
+    component.register_middleware(mapping)
+  end
+
+  autoload_all "faraday",
     :Middleware      => 'middleware',
     :Builder         => 'builder',
     :Request         => 'request',
@@ -62,14 +120,12 @@ module Faraday
     :CompositeReadIO => 'upload_io',
     :UploadIO        => 'upload_io',
     :Parts           => 'upload_io'
+
+  require_libs "utils", "connection", "adapter", "error"
 end
 
-require 'faraday/utils'
-require 'faraday/connection'
-require 'faraday/adapter'
-require 'faraday/error'
 
-# not pulling in active-support JUST for this method.
+# not pulling in active-support JUST for this method.  And I love this method.
 class Object
   # Yields <code>x</code> to the block, and then returns <code>x</code>.
   # The primary purpose of this method is to "tap into" a method chain,

data/test/adapters/default_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class DefaultTest < Faraday::TestCase
+
+    def adapter() :default end
+
+    Integration.apply(self, :NonParallel) do
+      # default stack is not configured with Multipart
+      undef :test_POST_sends_files
+    end
+
+  end
+end

data/test/adapters/em_http_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class EMHttpTest < Faraday::TestCase
+
+    def adapter() :em_http end
+
+    Integration.apply(self, :Parallel) do
+      # https://github.com/eventmachine/eventmachine/pull/289
+      undef :test_timeout
+    end
+
+  end
+end

data/test/adapters/em_synchrony_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class EMSynchronyTest < Faraday::TestCase
+
+    def adapter() :em_synchrony end
+
+    Integration.apply(self, :Parallel) do
+      # https://github.com/eventmachine/eventmachine/pull/289
+      undef :test_timeout
+    end
+
+  end unless RUBY_VERSION < '1.9' or (defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE)
+end

data/test/adapters/excon_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class ExconTest < Faraday::TestCase
+
+    def adapter() :excon end
+
+    # https://github.com/geemus/excon/issues/98
+    if defined?(RUBY_ENGINE) and "rbx" == RUBY_ENGINE
+      warn "Warning: Skipping Excon tests on Rubinius"
+    else
+      Integration.apply(self, :NonParallel) do
+        # https://github.com/eventmachine/eventmachine/pull/289
+        undef :test_timeout
+
+        # FIXME: this test fails on Travis with
+        # "Faraday::Error::ClientError: the server responded with status 400"
+        undef :test_POST_sends_files if ENV['CI']
+      end
+    end
+
+  end
+end