faraday 0.4.5 → 0.5.0

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/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/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

data/lib/faraday/connection.rb

@@ -4,14 +4,7 @@ require 'base64'
 
 module Faraday
   class Connection
-    include Addressable, Rack::Utils
-
-    HEADERS = Hash.new { |h, k| k.respond_to?(:to_str) ? k : k.to_s.capitalize }.update \
-      :content_type    => "Content-Type",
-      :content_length  => "Content-Length",
-      :accept_charset  => "Accept-Charset",
-      :accept_encoding => "Accept-Encoding"
-    HEADERS.values.each { |v| v.freeze }
+    include Addressable, Faraday::Utils
 
     METHODS = Set.new [:get, :post, :put, :delete, :head]
     METHODS_WITH_BODIES = Set.new [:post, :put]
@@ -38,35 +31,53 @@ module Faraday
       proxy(options[:proxy])
       merge_params  @params,  options[:params]  if options[:params]
       merge_headers @headers, options[:headers] if options[:headers]
+
       if block
-        @builder = Builder.create(&block)
+        @builder = Builder.new
+        @builder.build { block.call(self) }
       else
         @builder = options[:builder] || Builder.new
       end
     end
 
+    def use(klass, *args, &block)
+      @builder.use(klass, *args, &block)
+    end
+
+    def request(key, *args, &block)
+      @builder.request(key, *args, &block)
+    end
+
+    def response(key, *args, &block)
+      @builder.response(key, *args, &block)
+    end
+
+    def adapter(key, *args, &block)
+      @builder.adapter(key, *args, &block)
+    end
+
     def build(options = {}, &block)
       @builder.build(options, &block)
     end
 
     def get(url = nil, headers = nil, &block)
-      run_request :get, url, nil, headers, &block
+      run_request(:get, url, nil, headers, &block)
     end
 
     def post(url = nil, body = nil, headers = nil, &block)
-      run_request :post, url, body, headers, &block
+      run_request(:post, url, body, headers, &block)
     end
 
     def put(url = nil, body = nil, headers = nil, &block)
-      run_request :put, url, body, headers, &block
+      run_request(:put, url, body, headers, &block)
     end
 
     def head(url = nil, headers = nil, &block)
-      run_request :head, url, nil, headers, &block
+      run_request(:head, url, nil, headers, &block)
     end
 
     def delete(url = nil, headers = nil, &block)
-      run_request :delete, url, nil, headers, &block
+      run_request(:delete, url, nil, headers, &block)
     end
 
     def basic_auth(login, pass)
@@ -98,7 +109,7 @@ module Faraday
     def proxy(arg = nil)
       return @proxy if arg.nil?
 
-      @proxy = 
+      @proxy =
         case arg
           when String then {:uri => proxy_arg_to_uri(arg)}
           when URI    then {:uri => arg}
@@ -112,7 +123,7 @@ module Faraday
     end
 
     # Parses the giving url with Addressable::URI and stores the individual
-    # components in this connection.  These components serve as defaults for 
+    # components in this connection.  These components serve as defaults for
     # requests made by this connection.
     #
     #   conn = Faraday::Connection.new { ... }
@@ -131,6 +142,9 @@ module Faraday
       if uri.query && !uri.query.empty?
         merge_params @params, parse_query(uri.query)
       end
+      if uri.user && uri.password
+        basic_auth(uri.user, uri.password)
+      end
     end
 
     # Ensures that the path prefix always has a leading / and no trailing /
@@ -160,7 +174,7 @@ module Faraday
       end
     end
 
-    # Takes a relative url for a request and combines it with the defaults 
+    # Takes a relative url for a request and combines it with the defaults
     # set on the connection instance.
     #
     #   conn = Faraday::Connection.new { ... }
@@ -190,42 +204,15 @@ module Faraday
     def replace_query(uri, params)
       url_params = @params.dup
       if uri.query && !uri.query.empty?
-        merge_params url_params, parse_query(uri.query)
+        merge_params(url_params, parse_query(uri.query))
       end
       if params && !params.empty?
-        merge_params url_params, params
+        merge_params(url_params, params)
       end
       uri.query = url_params.empty? ? nil : build_query(url_params)
       uri
     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
-      end
-    end
-
-    # turns headers keys and values into strings.  Look up symbol keys in the 
-    # the HEADERS hash.  
-    #
-    #   h = merge_headers(HeaderHash.new, :content_type => 'text/plain')
-    #   h['Content-Type'] # = 'text/plain'
-    #
-    def merge_headers(existing_headers, new_headers)
-      new_headers.each do |key, value|
-        existing_headers[HEADERS[key]] = value.to_s
-      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! }
-      end
-    end
-
     def proxy_arg_to_uri(arg)
       case arg
         when String then URI.parse(arg)

data/lib/faraday/error.rb

@@ -1,6 +1,31 @@
 module Faraday
   module Error
-    class ConnectionFailed < StandardError; end
-    class ResourceNotFound < StandardError; end
+    class ClientError < StandardError
+      def initialize(exception)
+        @inner_exception = exception
+      end
+
+      def message
+        @inner_exception.message
+      end
+
+      def backtrace
+        @inner_exception.backtrace
+      end
+
+      alias to_str message
+
+      def to_s
+        @inner_exception.to_s
+      end
+
+      def inspect
+        @inner_exception.inspect
+      end
+    end
+
+    class ConnectionFailed < ClientError;   end
+    class ResourceNotFound < ClientError;   end
+    class ParsingError     < ClientError;   end
   end
 end

data/lib/faraday/middleware.rb

@@ -20,35 +20,5 @@ module Faraday
     def initialize(app = nil)
       @app = app
     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
-
-    def process_body_for_request(env)
-      # if it's a string, pass it through
-      return if env[:body].nil? || env[:body].empty? || !env[:body].respond_to?(:each_key)
-      env[:request_headers]['Content-Type'] ||= 'application/x-www-form-urlencoded'
-      env[:body] = create_form_params(env[:body])
-    end
-
-    def create_form_params(params, base = nil)
-      [].tap do |result|
-        params.each_key do |key|
-          key_str = base ? "#{base}[#{key}]" : key
-          value   = params[key]
-          wee = (value.kind_of?(Hash) ? create_form_params(value, key_str) : "#{key_str}=#{escape(value.to_s)}")
-          result << wee
-        end
-      end.join("&")
-    end
   end
 end

data/lib/faraday/request/active_support_json.rb

@@ -13,7 +13,7 @@ module Faraday
     def call(env)
       env[:request_headers]['Content-Type'] = 'application/json'
       if env[:body] && !env[:body].respond_to?(:to_str)
-        env[:body] = ActiveSupport::JSON.encode env[:body]
+        env[:body] = ActiveSupport::JSON.encode(env[:body])
       end
       @app.call env
     end

data/lib/faraday/request/yajl.rb

@@ -10,7 +10,7 @@ module Faraday
     def call(env)
       env[:request_headers]['Content-Type'] = 'application/json'
       if env[:body] && !env[:body].respond_to?(:to_str)
-        env[:body] = Yajl::Encoder.encode env[:body]
+        env[:body] = Yajl::Encoder.encode(env[:body])
       end
       @app.call env
     end

data/lib/faraday/request.rb

@@ -65,11 +65,11 @@ module Faraday
     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
+      connection.merge_headers(env_headers, headers)
+      connection.merge_params(env_params,  params)
 
-      { :method           => request_method, 
-        :body             => body, 
+      { :method           => request_method,
+        :body             => body,
         :url              => connection.build_url(path, env_params),
         :request_headers  => env_headers.update(headers),
         :parallel_manager => connection.parallel_manager,
@@ -84,4 +84,4 @@ module Faraday
       app.call(env)
     end
   end
-end
+end

data/lib/faraday/response/active_support_json.rb

@@ -8,16 +8,23 @@ module Faraday
 
       def self.register_on_complete(env)
         env[:response].on_complete do |finished_env|
-          finished_env[:body] = ActiveSupport::JSON.decode(finished_env[:body])
+          finished_env[:body] = parse(finished_env[:body])
+
         end
       end
     rescue LoadError, NameError => e
       self.load_error = e
     end
-    
+
     def initialize(app)
       super
       @parser = nil
     end
+
+    def self.parse(body)
+      ActiveSupport::JSON.decode(body)
+    rescue Object => err
+      raise Faraday::Error::ParsingError.new(err)
+    end
   end
 end

data/lib/faraday/response/yajl.rb

@@ -5,16 +5,22 @@ module Faraday
 
       def self.register_on_complete(env)
         env[:response].on_complete do |finished_env|
-          finished_env[:body] = Yajl::Parser.parse(finished_env[:body])
+          finished_env[:body] = parse(finished_env[:body])
         end
       end
     rescue LoadError, NameError => e
       self.load_error = e
     end
-    
+
     def initialize(app)
       super
       @parser = nil
     end
+
+    def self.parse(body)
+      Yajl::Parser.parse(body)
+    rescue Object => err
+      raise Faraday::Error::ParsingError.new(err)
+    end
   end
 end

data/lib/faraday/upload_io.rb

@@ -0,0 +1,15 @@
+begin
+  require 'composite_io'
+  require 'parts'
+  require 'stringio'
+rescue LoadError
+  puts "Install the multipart-post gem."
+  raise
+end
+
+# Auto-load multipart-post gem on first request.
+module Faraday
+  CompositeReadIO = ::CompositeReadIO
+  UploadIO        = ::UploadIO
+  Parts           = ::Parts
+end

data/lib/faraday/utils.rb

@@ -0,0 +1,64 @@
+require 'rack/utils'
+module Faraday
+  module Utils
+    include Rack::Utils
+
+    extend Rack::Utils
+    extend self
+
+    HEADERS = Hash.new do |h, k|
+      if k.respond_to?(:to_str)
+        k
+      else
+        k.to_s.split('_').            # :user_agent => %w(user agent)
+          each { |w| w.capitalize! }. # => %w(User Agent)
+          join('-')                   # => "User-Agent"
+      end
+    end
+
+    HEADERS.merge! :etag => "ETag"
+    HEADERS.values.each { |v| v.freeze }
+
+    # Make Rack::Utils build_query method public.
+    public :build_query
+
+    # 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! }
+      end
+    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
+      end
+    end
+
+    # Turns headers keys and values into strings.  Look up symbol keys in the
+    # the HEADERS hash.
+    #
+    #   h = merge_headers(HeaderHash.new, :content_type => 'text/plain')
+    #   h['Content-Type'] # = 'text/plain'
+    #
+    def merge_headers(existing_headers, new_headers)
+      new_headers.each do |key, value|
+        existing_headers[HEADERS[key]] = value.to_s
+      end
+    end
+
+    # Receives a URL and returns just the path with the query string sorted.
+    def normalize_path(url)
+      (url.path != "" ? url.path : "/") +
+      (url.query ? "?#{sort_query_params(url.query)}" : "")
+    end
+
+    protected
+
+    def sort_query_params(query)
+      query.split('&').sort.join('&')
+    end
+  end
+end

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>.