faraday 0.4.6 → 0.5.0

data/lib/faraday.rb

@@ -1,6 +1,6 @@
-require 'rack/utils'
-
 module Faraday
+  VERSION = "0.5.0"
+
   class << self
     attr_accessor :default_adapter
     attr_writer   :default_connection
@@ -42,37 +42,28 @@ module Faraday
     end
 
     def all_loaded_constants
-      constants.map { |c| const_get(c) }.select { |a| a.loaded? }
+      constants.map { |c| const_get(c) }.
+        select { |a| a.respond_to?(:loaded?) && a.loaded? }
     end
   end
 
   extend AutoloadHelper
 
-  autoload_all 'faraday', 
-    :Connection => 'connection',
-    :Middleware => 'middleware',
-    :Builder    => 'builder',
-    :Request    => 'request',
-    :Response   => 'response',
-    :Error      => 'error'
-
-  module Adapter
-    extend AutoloadHelper
-    autoload_all 'faraday/adapter',
-      :NetHttp  => 'net_http',
-      :Typhoeus => 'typhoeus',
-      :Patron   => 'patron',
-      :Test     => 'test'
-
-    register_lookup_modules \
-      :test     => :Test,
-      :net_http => :NetHttp,
-      :typhoeus => :Typhoeus,
-      :patron   => :Patron,
-      :net_http => :NetHttp
-  end
+  autoload_all 'faraday',
+    :Middleware      => 'middleware',
+    :Builder         => 'builder',
+    :Request         => 'request',
+    :Response        => 'response',
+    :CompositeReadIO => 'upload_io',
+    :UploadIO        => 'upload_io',
+    :Parts           => 'upload_io'
 end
 
+require 'faraday/utils'
+require 'faraday/connection'
+require 'faraday/adapter'
+require 'faraday/error'
+
 # not pulling in active-support JUST for this method.
 class Object
   # Yields <code>x</code> to the block, and then returns <code>x</code>.

data/lib/faraday/adapter.rb

@@ -0,0 +1,102 @@
+module Faraday
+  class Adapter < Middleware
+    FORM_TYPE        = 'application/x-www-form-urlencoded'.freeze
+    MULTIPART_TYPE   = 'multipart/form-data'.freeze
+    CONTENT_TYPE     = 'Content-Type'.freeze
+    DEFAULT_BOUNDARY = "-----------RubyMultipartPost".freeze
+
+    extend AutoloadHelper
+    autoload_all 'faraday/adapter',
+      :ActionDispatch => 'action_dispatch',
+      :NetHttp        => 'net_http',
+      :Typhoeus       => 'typhoeus',
+      :Patron         => 'patron',
+      :Test           => 'test'
+
+    register_lookup_modules \
+      :action_dispatch => :ActionDispatch,
+      :test            => :Test,
+      :net_http        => :NetHttp,
+      :typhoeus        => :Typhoeus,
+      :patron          => :Patron,
+      :net_http        => :NetHttp
+
+    def call(env)
+      process_body_for_request(env)
+    end
+
+    # Converts a body hash into encoded form params.  This is done as late
+    # as possible in the request cycle in case some other middleware wants to
+    # act on the request before sending it out.
+    #
+    # env     - The current request environment Hash.
+    # body    - A Hash of keys/values.  Strings and empty values will be
+    #           ignored.  Default: env[:body]
+    # headers - The Hash of request headers.  Default: env[:request_headers]
+    #
+    # Returns nothing.  If the body is processed, it is replaced in the
+    # environment for you.
+    def process_body_for_request(env, body = env[:body], headers = env[:request_headers])
+      return if body.nil? || body.empty? || !body.respond_to?(:each_key)
+      if has_multipart?(body)
+        env[:request]            ||= {}
+        env[:request][:boundary] ||= DEFAULT_BOUNDARY
+        headers[CONTENT_TYPE]      = MULTIPART_TYPE + ";boundary=#{env[:request][:boundary]}"
+        env[:body] = create_multipart(env, body)
+      else
+        type = headers[CONTENT_TYPE]
+        headers[CONTENT_TYPE] = FORM_TYPE if type.nil? || type.empty?
+        parts = []
+        process_to_params(parts, env[:body]) do |key, value|
+          "#{key}=#{escape(value.to_s)}"
+        end
+        env[:body] = parts * "&"
+      end
+    end
+
+    def has_multipart?(body)
+      body.values.each do |v|
+        if v.respond_to?(:content_type)
+          return true
+        elsif v.respond_to?(:values)
+          return true if has_multipart?(v)
+        end
+      end
+      false
+    end
+
+    def create_multipart(env, params, boundary = nil)
+      boundary ||= env[:request][:boundary]
+      parts      = []
+      process_to_params(parts, params) do |key, value|
+        Faraday::Parts::Part.new(boundary, key, value)
+      end
+      parts     << Faraday::Parts::EpiloguePart.new(boundary)
+      env[:request_headers]['Content-Length'] = parts.inject(0) {|sum,i| sum + i.length }.to_s
+      Faraday::CompositeReadIO.new(*parts.map{|p| p.to_io })
+    end
+
+    def process_to_params(pieces, params, base = nil, &block)
+      params.each do |key, value|
+        key_str = base ? "#{base}[#{key}]" : key
+        if value.kind_of?(Hash)
+          process_to_params(pieces, value, key_str, &block)
+        else
+          pieces << block.call(key_str, value)
+        end
+      end
+    end
+
+    # assume that query and fragment are already encoded properly
+    def full_path_for(path, query = nil, fragment = nil)
+      full_path = path.dup
+      if query && !query.empty?
+        full_path << "?#{query}"
+      end
+      if fragment && !fragment.empty?
+        full_path << "##{fragment}"
+      end
+      full_path
+    end
+  end
+end

data/lib/faraday/adapter/action_dispatch.rb

@@ -0,0 +1,39 @@
+module Faraday
+  class Adapter
+    class ActionDispatch < Faraday::Adapter
+      attr_reader :session
+
+      # Initializes a new middleware instance for each request.  Instead of
+      # initiating an HTTP request with a web server, this adapter calls
+      # a Rails 3 app using integration tests.
+      #
+      # app     - The current Faraday request.
+      # session - An ActionDispatch::Integration::Session instance.
+      #
+      # Returns nothing.
+      def initialize(app, session)
+        super(app)
+        @session = session
+        @session.reset!
+      end
+
+      def call(env)
+        super
+        full_path = full_path_for(env[:url].path, env[:url].query, env[:url].fragment)
+        @session.__send__(env[:method], full_path, env[:body], env[:request_headers])
+        resp = @session.response
+        env.update \
+          :status           => resp.status,
+          :response_headers => resp.headers,
+          :body             => resp.body
+        @app.call env
+      end
+
+      # TODO: build in support for multipart streaming if action dispatch supports it.
+      def create_multipart(env, params, boundary = nil)
+        stream = super
+        stream.read
+      end
+    end
+  end
+end

data/lib/faraday/adapter/net_http.rb

@@ -6,10 +6,10 @@ rescue LoadError
 end
 
 module Faraday
-  module Adapter
-    class NetHttp < Middleware
+  class Adapter
+    class NetHttp < Faraday::Adapter
       def call(env)
-        process_body_for_request(env)
+        super
 
         is_ssl = env[:url].scheme == 'https'
 
@@ -28,9 +28,21 @@ module Faraday
         req = env[:request]
         http.read_timeout = net.open_timeout = req[:timeout] if req[:timeout]
         http.open_timeout = req[:open_timeout]               if req[:open_timeout]
-        
+
         full_path = full_path_for(env[:url].path, env[:url].query, env[:url].fragment)
-        http_resp = http.send_request(env[:method].to_s.upcase, full_path, env[:body], env[:request_headers])
+        http_req  = Net::HTTPGenericRequest.new(
+          env[:method].to_s.upcase,    # request method
+          (env[:body] ? true : false), # is there data
+          true,                        # does net/http love you, true or false?
+          full_path,                   # request uri path
+          env[:request_headers])       # request headers
+
+        if env[:body].respond_to?(:read)
+          http_req.body_stream = env[:body]
+          env[:body] = nil
+        end
+
+        http_resp = http.request http_req, env[:body]
 
         resp_headers = {}
         http_resp.each_header do |key, value|
@@ -38,13 +50,13 @@ module Faraday
         end
 
         env.update \
-          :status           => http_resp.code.to_i, 
-          :response_headers => resp_headers, 
+          :status           => http_resp.code.to_i,
+          :response_headers => resp_headers,
           :body             => http_resp.body
 
         @app.call env
       rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, "connection refused"
+        raise Error::ConnectionFailed.new(Errno::ECONNREFUSED)
       end
 
       def net_http_class(env)

data/lib/faraday/adapter/patron.rb

@@ -1,6 +1,6 @@
 module Faraday
-  module Adapter
-    class Patron < Middleware
+  class Adapter
+    class Patron < Faraday::Adapter
       begin
         require 'patron'
       rescue LoadError, NameError => e
@@ -8,7 +8,7 @@ module Faraday
       end
 
       def call(env)
-        process_body_for_request(env)
+        super
 
         sess = ::Patron::Session.new
         args = [env[:method], env[:url].to_s, env[:request_headers]]
@@ -26,7 +26,13 @@ module Faraday
 
         @app.call env
       rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, "connection refused"
+        raise Error::ConnectionFailed.new(Errno::ECONNREFUSED)
+      end
+
+      # TODO: build in support for multipart streaming if patron supports it.
+      def create_multipart(env, params, boundary = nil)
+        stream = super
+        stream.read
       end
     end
   end

data/lib/faraday/adapter/test.rb

@@ -1,5 +1,5 @@
 module Faraday
-  module Adapter
+  class Adapter
     # test = Faraday::Connection.new do
     #   use Faraday::Adapter::Test do |stub|
     #     stub.get '/nigiri/sake.json' do
@@ -19,7 +19,7 @@ module Faraday
       class Stubs
         def initialize
           # {:get => [Stub, Stub]}
-          @stack = {}
+          @stack, @consumed = {}, {}
           yield self if block_given?
         end
 
@@ -29,8 +29,15 @@ module Faraday
 
         def match(request_method, path, body)
           return false if !@stack.key?(request_method)
-          stub = @stack[request_method].detect { |stub| stub.matches?(path, body) }
-          @stack[request_method].delete stub
+          stack = @stack[request_method]
+          consumed = (@consumed[request_method] ||= [])
+
+          if stub = matches?(stack, path, body)
+            consumed << stack.delete(stub)
+            stub
+          else
+            matches?(consumed, path, body)
+          end
         end
 
         def get(path, &block)
@@ -53,10 +60,6 @@ module Faraday
           new_stub(:delete, path, &block)
         end
 
-        def new_stub(request_method, path, body=nil, &block)
-          (@stack[request_method] ||= []) << Stub.new(path, body, block)
-        end
-
         # Raises an error if any of the stubbed calls have not been made.
         def verify_stubbed_calls
           failed_stubs = []
@@ -69,6 +72,16 @@ module Faraday
           end
           raise failed_stubs.join(" ") unless failed_stubs.size == 0
         end
+
+        protected
+
+        def new_stub(request_method, path, body=nil, &block)
+          (@stack[request_method] ||= []) << Stub.new(path, body, block)
+        end
+
+        def matches?(stack, path, body)
+          stack.detect { |stub| stub.matches?(path, body) }
+        end
       end
 
       class Stub < Struct.new(:path, :body, :block)
@@ -81,7 +94,7 @@ module Faraday
         end
       end
 
-      def initialize app, stubs=nil, &block
+      def initialize(app, stubs=nil, &block)
         super(app)
         @stubs = stubs || Stubs.new
         configure(&block) if block
@@ -91,13 +104,8 @@ module Faraday
         yield stubs
       end
 
-      def request_uri url
-        (url.path != "" ? url.path : "/") +
-        (url.query ? "?#{url.query}" : "")
-      end
-
       def call(env)
-        if stub = stubs.match(env[:method], request_uri(env[:url]), env[:body])
+        if stub = stubs.match(env[:method], Faraday::Utils.normalize_path(env[:url]), env[:body])
           status, headers, body = stub.block.call(env)
           env.update \
             :status           => status,
@@ -108,6 +116,11 @@ module Faraday
         end
         @app.call(env)
       end
+
+      def create_multipart(env, params, boundary = nil)
+        stream = super
+        stream.read
+      end
     end
   end
 end

data/lib/faraday/adapter/typhoeus.rb

@@ -1,6 +1,6 @@
 module Faraday
-  module Adapter
-    class Typhoeus < Middleware
+  class Adapter
+    class Typhoeus < Faraday::Adapter
       self.supports_parallel_requests = true
 
       def self.setup_parallel_manager(options = {})
@@ -14,15 +14,18 @@ module Faraday
       end
 
       def call(env)
-        process_body_for_request(env)
+        super
 
-        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
-        req   = ::Typhoeus::Request.new env[:url].to_s, 
+        req   = ::Typhoeus::Request.new env[:url].to_s,
           :method  => env[:method],
           :body    => env[:body],
           :headers => env[:request_headers],
           :disable_ssl_peer_verification => (env[:ssl][:verify] == false)
 
+        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]
+
         req.on_complete do |resp|
           env.update \
             :status           => resp.code,
@@ -31,6 +34,7 @@ module Faraday
           env[:response].finish(env)
         end
 
+        hydra = env[:parallel_manager] || self.class.setup_parallel_manager
         hydra.queue req
 
         if !env[:parallel_manager]
@@ -39,7 +43,7 @@ module Faraday
 
         @app.call env
       rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, "connection refused"
+        raise Error::ConnectionFailed.new(Errno::ECONNREFUSED)
       end
 
       def in_parallel(options = {})
@@ -56,6 +60,12 @@ module Faraday
           map! { |h|      h.split(/:\s+/,2) }. # split key and value
           map! { |(k, v)| [k.downcase, v]   }.flatten!]
       end
+
+      # TODO: build in support for multipart streaming if typhoeus supports it.
+      def create_multipart(env, params, boundary = nil)
+        stream = super
+        stream.read
+      end
     end
   end
 end

data/lib/faraday/builder.rb

@@ -14,7 +14,7 @@ module Faraday
     end
 
     def self.inner_app
-      lambda do |env| 
+      lambda do |env|
         env[:parallel_manager] ? env[:response] : env[:response].finish(env)
       end
     end
@@ -56,19 +56,19 @@ module Faraday
     end
 
     def request(key, *args, &block)
-      use_symbol Faraday::Request, key, *args, &block
+      use_symbol(Faraday::Request, key, *args, &block)
     end
 
     def response(key, *args, &block)
-      use_symbol Faraday::Response, key, *args, &block
+      use_symbol(Faraday::Response, key, *args, &block)
     end
 
     def adapter(key, *args, &block)
-      use_symbol Faraday::Adapter, key, *args, &block
+      use_symbol(Faraday::Adapter, key, *args, &block)
     end
 
     def use_symbol(mod, key, *args, &block)
-      use mod.lookup_module(key), *args, &block
+      use(mod.lookup_module(key), *args, &block)
     end
 
     def ==(other)
@@ -76,7 +76,7 @@ module Faraday
     end
 
     def dup
-      self.class.new @handlers.dup
+      self.class.new(@handlers.dup)
     end
   end
 end