faraday 0.7.6 → 0.8.0.rc2

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,8 +16,18 @@ 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?
-      !defined? @load_error or @load_error.nil?
+      load_error.nil?
+    end
+
+    def self.inherited(subclass)
+      super
+      subclass.send(:load_error=, self.load_error)
     end
 
     def initialize(app = nil)

data/lib/faraday/request.rb

@@ -9,20 +9,24 @@ module Faraday
   #     req.body = 'abc'
   #   end
   #
-  class Request < Struct.new(:path, :params, :headers, :body, :options)
+  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',
+      :BasicAuthentication => 'basic_authentication',
+      :TokenAuthentication => 'token_authentication'
 
-    register_lookup_modules \
-      :json        => :JSON,
+    register_middleware \
       :url_encoded => :UrlEncoded,
-      :multipart   => :Multipart
-
-    attr_reader :method
+      :multipart   => :Multipart,
+      :retry       => :Retry,
+      :basic_auth  => :BasicAuthentication,
+      :token_auth  => :TokenAuthentication
 
     def self.create(request_method)
       new(request_method).tap do |request|
@@ -30,16 +34,32 @@ module Faraday
       end
     end
 
-    def initialize(request_method)
-      @method = request_method
-      self.params  = {}
-      self.headers = {}
-      self.options = {}
+    # 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)
@@ -53,7 +73,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
@@ -67,17 +87,12 @@ module Faraday
     #     :password   - Proxy server password
     # :ssl - Hash of options for configuring SSL requests.
     def to_env(connection)
-      env_params  = connection.params.merge(params)
-      env_headers = connection.headers.merge(headers)
-      request_options = Utils.deep_merge(connection.options, options)
-      Utils.deep_merge!(request_options, :proxy => connection.proxy)
-
       { :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          => request_options,
+        :request          => options,
         :ssl              => connection.ssl}
     end
   end

data/lib/faraday/request/basic_authentication.rb

@@ -0,0 +1,17 @@
+require 'base64'
+
+module Faraday
+  class Request::BasicAuthentication < Faraday::Middleware
+    def initialize(app, login, pass)
+      super(app)
+      @header_value = "Basic #{Base64.encode64([login, pass].join(':')).gsub("\n", '')}"
+    end
+
+    def call(env)
+      unless env[:request_headers]['Authorization']
+        env[:request_headers]['Authorization'] = @header_value
+      end
+      @app.call(env)
+    end
+  end
+end

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,21 @@
+module Faraday
+  class Request::TokenAuthentication < Faraday::Middleware
+    def initialize(app, token, options={})
+      super(app)
+
+      values = ["token=#{token.to_s.inspect}"]
+      options.each do |key, value|
+        values << "#{key}=#{value.to_s.inspect}"
+      end
+      comma = ",\n#{' ' * ('Authorization: Token '.size)}"
+      @header_value = "Token #{values * comma}"
+    end
+
+    def call(env)
+      unless env[:request_headers]['Authorization']
+        env[:request_headers]['Authorization'] = @header_value
+      end
+      @app.call(env)
+    end
+  end
+end

data/lib/faraday/response.rb

@@ -21,12 +21,13 @@ module Faraday
 
     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
 

data/lib/faraday/utils.rb

@@ -1,13 +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
@@ -20,17 +24,53 @@ module Faraday
       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/).
@@ -92,7 +132,7 @@ module Faraday
       end
 
       def to_query
-        Utils.build_query(self)
+        Utils.build_nested_query(self)
       end
 
       private
@@ -102,10 +142,18 @@ module Faraday
       end
     end
 
-    # Make Rack::Utils methods public.
-    public :build_query, :parse_query
+    # 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
@@ -122,14 +170,70 @@ module Faraday
       end
     end
 
-    # Be sure to URI escape '+' symbols to %2B. Otherwise, they get interpreted
-    # as spaces.
-    def escape(s)
-      s = s.to_s
-      s = s.dup.force_encoding('binary') if s.respond_to? :force_encoding
-      s.gsub(/([^a-zA-Z0-9_.-]+)/n) do |match|
-        '%' << match.unpack('H2'*bytesize(match)).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
+
+    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
+
+    # 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.

data/test/adapters/live_test.rb

@@ -6,10 +6,10 @@ else
   module Adapters
     class LiveTest < Faraday::TestCase
       adapters = if ENV['ADAPTER']
-        ENV['ADAPTER'].split(':').map { |name| Faraday::Adapter.lookup_module name.to_sym }
+        ENV['ADAPTER'].split(':').map { |name| Faraday::Adapter.lookup_middleware name.to_sym }
       else
         loaded_adapters  = Faraday::Adapter.all_loaded_constants
-        loaded_adapters -= [Faraday::Adapter::ActionDispatch]
+        loaded_adapters -= [Faraday::Adapter::Test, Faraday::Adapter::ActionDispatch]
         # https://github.com/geemus/excon/issues/98
         loaded_adapters -= [Faraday::Adapter::Excon] if defined? RUBY_ENGINE and "rbx" == RUBY_ENGINE
         loaded_adapters << :default
@@ -108,18 +108,16 @@ else
         end
 
         # https://github.com/toland/patron/issues/34
-        unless %w[Faraday::Adapter::Patron Faraday::Adapter::EMSynchrony].include? adapter.to_s
+        unless %w[Faraday::Adapter::Patron].include? adapter.to_s
           define_method "test_#{adapter}_PATCH_send_url_encoded_params" do
             resp = create_connection(adapter).patch('echo_name', 'name' => 'zack')
             assert_equal %("zack"), resp.body
           end
         end
 
-        unless %[Faraday::Adapter::EMSynchrony] == adapter.to_s
-          define_method "test_#{adapter}_OPTIONS" do
-            resp = create_connection(adapter).run_request(:options, '/options', nil, {})
-            assert_equal "hi", resp.body
-          end
+        define_method "test_#{adapter}_OPTIONS" do
+          resp = create_connection(adapter).run_request(:options, '/options', nil, {})
+          assert_equal "hi", resp.body
         end
 
         define_method "test_#{adapter}_HEAD_send_url_encoded_params" do
@@ -145,32 +143,38 @@ else
           assert_match(/deleted/, create_connection(adapter).delete('delete_with_json').body)
         end
 
-        define_method "test_#{adapter}_async_requests_clear_parallel_manager_after_running_a_single_request" do
-          connection = create_connection(adapter)
-          assert !connection.in_parallel?
-          connection.get('hello_world')
-          assert !connection.in_parallel?
-          assert_equal 'hello world', connection.get('hello_world').body
-        end
-
-        define_method "test_#{adapter}_async_requests_uses_parallel_manager_to_run_multiple_json_requests" do
-          resp1, resp2 = nil, nil
+        if :default != adapter and adapter.supports_parallel?
+          define_method "test_#{adapter}_in_parallel" do
+            resp1, resp2 = nil, nil
 
-          connection = create_connection(adapter)
-          adapter    = real_adapter_for(adapter)
+            connection = create_connection(adapter)
+            klass      = real_adapter_for(adapter)
 
-          connection.in_parallel(adapter.setup_parallel_manager) do
-            resp1 = connection.get('json')
-            resp2 = connection.get('json')
-            if adapter.supports_parallel_requests?
+            connection.in_parallel do
+              resp1 = connection.get('echo?a=1')
+              resp2 = connection.get('echo?b=2')
               assert connection.in_parallel?
               assert_nil resp1.body
               assert_nil resp2.body
             end
+            assert !connection.in_parallel?
+            assert_equal 'get ?{"a"=>"1"}', resp1.body
+            assert_equal 'get ?{"b"=>"2"}', resp2.body
+          end
+        else
+          define_method "test_#{adapter}_no_parallel_support" do
+            connection = create_connection(adapter)
+            response = nil
+
+            err = capture_warnings do
+              connection.in_parallel do
+                response = connection.get('echo').body
+              end
+            end
+            assert response
+            assert_match "no parallel-capable adapter on Faraday stack", err
+            assert_match __FILE__, err
           end
-          assert !connection.in_parallel?
-          assert_equal '[1,2,3]', resp1.body
-          assert_equal '[1,2,3]', resp2.body
         end
 
         if adapter.to_s == "Faraday::Adapter::EMSynchrony"
@@ -187,9 +191,10 @@ else
           end
         end
 
-        if %w[Faraday::Adapter::Patron Faraday::Adapter::NetHttp].include?(adapter.to_s)
+        # https://github.com/eventmachine/eventmachine/pull/289
+        unless %w[Faraday::Adapter::EMHttp Faraday::Adapter::EMSynchrony Faraday::Adapter::Excon].include?(adapter.to_s)
           define_method "test_#{adapter}_timeout" do
-            conn = create_connection(adapter, :request => {:timeout => 1, :read_timeout => 1})
+            conn = create_connection(adapter, :request => {:timeout => 1, :open_timeout => 1})
             assert_raise Faraday::Error::TimeoutError do
               conn.get '/slow'
             end
@@ -217,7 +222,7 @@ else
 
       def real_adapter_for(adapter)
         if adapter == :default
-          Faraday::Adapter.lookup_module(Faraday.default_adapter)
+          Faraday::Adapter.lookup_middleware(Faraday.default_adapter)
         else
           adapter
         end