faraday 0.5.7 → 0.6.0

data/Gemfile

@@ -4,15 +4,16 @@ source "http://rubygems.org"
 # put test-only gems in this group so their generators
 # and rake tasks are available in development mode:
 group :development, :test do
-  gem 'patron', '~> 0.4'
+  gem 'patron', '~> 0.4', :platforms => :ruby
   gem 'sinatra', '~> 1.1'
-  gem 'typhoeus', '~> 0.2'
-  gem 'eventmachine', '~> 0.12'
-  gem 'em-http-request', '~> 0.3', :require => 'em-http'
-  major, minor, patch = RUBY_VERSION.split('.')
-  if major.to_i >= 1 && minor.to_i >= 9
-    gem 'em-synchrony', '~> 0.2', :require => ['em-synchrony', 'em-synchrony/em-http']
-  end
+  gem 'typhoeus', '~> 0.2', :platforms => :ruby
+  gem 'excon', '~> 0.5.8'
+  gem 'em-http-request', '~> 0.3', :require => 'em-http', :platforms => :ruby
+  gem 'em-synchrony', '~> 0.2', :require => ['em-synchrony', 'em-synchrony/em-http'], :platforms => :ruby_19
+  gem 'webmock'
+  # ActiveSupport::JSON will be used in ruby 1.8 and Yajl in 1.9; this is to test against both adapters
+  gem 'activesupport', '~> 2.3.8', :require => nil, :platforms => [:ruby_18, :jruby]
+  gem 'yajl-ruby', :require => 'yajl', :platforms => :ruby_19
 end
 
 gemspec

data/README.md

@@ -7,30 +7,109 @@ This mess is gonna get raw, like sushi. So, haters to the left.
 ## Usage
 
     conn = Faraday.new(:url => 'http://sushi.com') do |builder|
-      builder.use Faraday::Request::Yajl        # convert body to json with Yajl lib
-      builder.use Faraday::Adapter::Logger      # log the request somewhere?
-      builder.use Faraday::Adapter::Typhoeus    # make http request with typhoeus
-      builder.use Faraday::Adapter::EMSynchrony # make http request with eventmachine and synchrony
-      builder.use Faraday::Response::Yajl       # parse body with yajl
-
-      # or use shortcuts
-      builder.request  :yajl         # Faraday::Request::Yajl
-      builder.adapter  :logger       # Faraday::Adapter::Logger
-      builder.adapter  :typhoeus     # Faraday::Adapter::Typhoeus
-      builder.adapter  :em_synchrony # Faraday::Adapter::EMSynchrony
-      builder.response :yajl         # Faraday::Response::Yajl
+      builder.use Faraday::Request::UrlEncoded  # convert request params as "www-form-urlencoded"
+      builder.use Faraday::Request::JSON        # encode request params as json
+      builder.use Faraday::Response::Logger     # log the request to STDOUT
+      builder.use Faraday::Adapter::NetHttp     # make http requests with Net::HTTP
+
+      # or, use shortcuts:
+      builder.request  :url_encoded
+      builder.request  :json
+      builder.response :logger
+      builder.adapter  :net_http
     end
+    
+    ## GET ##
 
-    resp1 = conn.get '/nigiri/sake.json'
-    resp2 = conn.post do |req|
-      req.url  "/nigiri.json", :page => 2
-      req.params['limit'] = 100 # &limit=100
-      req.headers["Content-Type"] = 'application/json'
-      req.body = {:name => 'Unagi'}
+    response = conn.get '/nigiri/sake.json'     # GET http://sushi.com/nigiri/sake.json
+    response.body
+
+    conn.get '/nigiri', 'X-Awesome' => true     # custom request header
+    
+    conn.get do |req|                           # GET http://sushi.com/search?page=2&limit=100
+      req.url '/search', :page => 2
+      req.params['limit'] = 100
+    end
+    
+    ## POST ##
+    
+    conn.post '/nigiri', { :name => 'Maguro' }  # POST "name=maguro" to http://sushi.com/nigiri
+    
+    # post payload as JSON instead of "www-form-urlencoded" encoding:
+    conn.post '/nigiri', payload, 'Content-Type' => 'application/json'
+
+    # a more verbose way:
+    conn.post do |req|
+      req.url '/nigiri'
+      req.headers['Content-Type'] = 'application/json'
+      req.body = { :name => 'Unagi' }
+    end
+
+If you're ready to roll with just the bare minimum:
+
+    # default stack (net/http), no extra middleware:
+    response = Faraday.get 'http://sushi.com/nigiri/sake.json'
+
+## Advanced middleware usage
+
+The order in which middleware is stacked is important. Like with Rack, the first middleware on the list wraps all others, while the last middleware is the innermost one, so that's usually the adapter.
+
+    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
+      # POST/PUT params encoders:
+      builder.request  :multipart
+      builder.request  :url_encoded
+      builder.request  :json
+      
+      builder.adapter  :net_http
+    end
+
+This request middleware setup affects POST/PUT requests in the following way:
+
+1. `Request::Multipart` checks for files in the payload, otherwise leaves everything untouched;
+2. `Request::UrlEncoded` encodes as "application/x-www-form-urlencoded" if not already encoded or of another type
+2. `Request::JSON` encodes as "application/json" if not already encoded or of another type
+
+Because "UrlEncoded" is higher on the stack than JSON encoder, it will get to process the request first. Swapping them means giving the other priority. Specifying the "Content-Type" for the request is explicitly stating which middleware should process it.
+
+Examples:
+
+    payload = { :name => 'Maguro' }
+    
+    # post payload as JSON instead of urlencoded:
+    conn.post '/nigiri', payload, 'Content-Type' => 'application/json'
+    
+    # uploading a file:
+    payload = { :profile_pic => Faraday::UploadIO.new('avatar.jpg', 'image/jpeg') }
+    
+    # "Multipart" middleware detects files and encodes with "multipart/form-data":
+    conn.put '/profile', payload
+
+## Writing middleware
+
+Middleware are classes that respond to `call()`. They wrap the request/response cycle.
+
+    def call(env)
+      # do something with the request
+      
+      @app.call(env).on_complete do
+        # do something with the response
+      end
     end
 
-    # If you're ready to roll with just the bare minimum (net/http):
-    resp1 = Faraday.get 'http://sushi.com/nigiri/sake.json'
+It's important to do all processing of the response only in the `on_complete` block. This enables middleware to work in parallel mode where requests are asynchronous.
+
+The `env` is a hash with symbol keys that contains info about the request and, later, response. Some keys are:
+
+    # request phase
+    :method - :get, :post, ...
+    :url    - URI for the current request; also contains GET parameters
+    :body   - POST parameters for :post/:put requests
+    :request_headers
+
+    # response phase
+    :status - HTTP response status code, such as 200
+    :body   - the response body
+    :response_headers
 
 ## Testing
 

data/faraday.gemspec

@@ -12,8 +12,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'faraday'
-  s.version           = '0.5.7'
-  s.date              = '2011-02-27'
+  s.version           = '0.6.0'
+  s.date              = '2011-03-31'
   s.rubyforge_project = 'faraday'
 
   ## Make sure your summary is short. The description may be as long
@@ -52,7 +52,6 @@ Gem::Specification.new do |s|
     lib/faraday/adapter/action_dispatch.rb
     lib/faraday/adapter/em_synchrony.rb
     lib/faraday/adapter/excon.rb
-    lib/faraday/adapter/logger.rb
     lib/faraday/adapter/net_http.rb
     lib/faraday/adapter/patron.rb
     lib/faraday/adapter/test.rb
@@ -62,24 +61,23 @@ Gem::Specification.new do |s|
     lib/faraday/error.rb
     lib/faraday/middleware.rb
     lib/faraday/request.rb
-    lib/faraday/request/active_support_json.rb
-    lib/faraday/request/yajl.rb
+    lib/faraday/request/json.rb
+    lib/faraday/request/multipart.rb
+    lib/faraday/request/url_encoded.rb
     lib/faraday/response.rb
-    lib/faraday/response/active_support_json.rb
-    lib/faraday/response/yajl.rb
+    lib/faraday/response/logger.rb
+    lib/faraday/response/raise_error.rb
     lib/faraday/upload_io.rb
     lib/faraday/utils.rb
     test/adapters/live_test.rb
     test/adapters/logger_test.rb
+    test/adapters/net_http_test.rb
     test/adapters/test_middleware_test.rb
-    test/adapters/typhoeus_test.rb
-    test/connection_app_test.rb
     test/connection_test.rb
     test/env_test.rb
-    test/form_post_test.rb
     test/helper.rb
     test/live_server.rb
-    test/multipart_test.rb
+    test/middleware_stack_test.rb
     test/request_middleware_test.rb
     test/response_middleware_test.rb
   ]

data/lib/faraday.rb

@@ -1,5 +1,5 @@
 module Faraday
-  VERSION = "0.5.7"
+  VERSION = "0.6.0"
 
   class << self
     attr_accessor :default_adapter

data/lib/faraday/adapter.rb

@@ -1,11 +1,9 @@
 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
+    CONTENT_LENGTH = 'Content-Length'.freeze
 
     extend AutoloadHelper
+
     autoload_all 'faraday/adapter',
       :ActionDispatch => 'action_dispatch',
       :NetHttp        => 'net_http',
@@ -13,8 +11,7 @@ module Faraday
       :EMSynchrony    => 'em_synchrony',
       :Patron         => 'patron',
       :Excon          => 'excon',
-      :Test           => 'test',
-      :Logger         => 'logger'
+      :Test           => 'test'
 
     register_lookup_modules \
       :action_dispatch => :ActionDispatch,
@@ -23,91 +20,19 @@ module Faraday
       :typhoeus        => :Typhoeus,
       :patron          => :Patron,
       :em_synchrony    => :EMSynchrony,
-      :excon           => :Excon,
-      :logger          => :Logger
+      :excon           => :Excon
 
     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
+      if !env[:body] and Connection::METHODS_WITH_BODIES.include? env[:method]
+        # play nice and indicate we're sending an empty body
+        env[:request_headers][CONTENT_LENGTH] = "0"
+        # Typhoeus hangs on PUT requests if body is nil
+        env[:body] = ''
       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)
-      params.to_a.each do |key, value|
-        key_str = base ? "#{base}[#{key}]" : key
-
-        block = block_given? ? Proc.new : nil
-        case value
-        when Array
-          values = value.inject([]) { |a,v| a << [nil, v] }
-          process_to_params(pieces, values, key_str, &block)
-        when 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
+    def response_headers(env)
+      env[:response_headers] ||= Utils::Headers.new
     end
   end
 end

data/lib/faraday/adapter/action_dispatch.rb

@@ -19,21 +19,12 @@ module Faraday
 
       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])
+        @session.__send__(env[:method], env[:url].request_uri, env[:body], env[:request_headers])
         resp = @session.response
-        env.update \
-          :status           => resp.status,
-          :response_headers => resp.headers,
-          :body             => resp.body
+        env.update :status => resp.status, :body => resp.body
+        response_headers(env).update resp.headers
         @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/em_synchrony.rb

@@ -1,33 +1,17 @@
 module Faraday
   class Adapter
     class EMSynchrony < Faraday::Adapter
-      begin
+      dependency do
         require 'em-synchrony/em-http'
         require 'fiber'
-      rescue LoadError, NameError => e
-        self.load_error = e
-      end
-
-      class Header
-        include Net::HTTPHeader
-        def initialize response
-          @header = {}
-          response.response_header.each do |key, value|
-            case key
-            when "CONTENT_TYPE"; self.content_type = value
-            when "CONTENT_LENGTH"; self.content_length = value
-            else; self[key] = value
-            end
-          end
-        end
       end
 
       def call(env)
-        process_body_for_request(env)
+        super
         request = EventMachine::HttpRequest.new(URI::parse(env[:url].to_s))
         options = {:head => env[:request_headers]}
         options[:ssl] = env[:ssl] if env[:ssl]
-        
+
         if env[:body]
           if env[:body].respond_to? :read
             options[:body] = env[:body].read
@@ -41,7 +25,7 @@ module Faraday
             uri = Addressable::URI.parse(proxy[:uri])
             options[:proxy] = {
               :host => uri.host,
-              :port => uri.port
+              :port => uri.inferred_port
             }
             if proxy[:username] && proxy[:password]
               options[:proxy][:authorization] = [proxy[:username], proxy[:password]]
@@ -67,13 +51,14 @@ module Faraday
           client = block.call
         end
 
-        env.update(:status           => client.response_header.http_status.to_i,
-                   :response_headers => Header.new(client),
-                   :body             => client.response)
+        client.response_header.each do |name, value|
+          response_headers(env)[name.to_sym] = value
+        end
+        env.update :status => client.response_header.status, :body => client.response
 
         @app.call env
       rescue Errno::ECONNREFUSED
-        raise Error::ConnectionFailed, "connection refused"
+        raise Error::ConnectionFailed, $!
       end
     end
   end

data/lib/faraday/adapter/excon.rb

@@ -1,21 +1,15 @@
 module Faraday
   class Adapter
     class Excon < Faraday::Adapter
-      begin
-        require 'excon'
-      rescue LoadError, NameError => e
-        self.load_error = e
-      end
+      dependency 'excon'
 
       def call(env)
         super
 
         conn = ::Excon.new(env[:url].to_s)
         if ssl = (env[:url].scheme == 'https' && env[:ssl])
-          ::Excon.ssl_verify_peer = !!ssl[:verify] if ssl.key?(:verify)
-          if ca_file = ssl[:ca_file]
-            ::Excon.ssl_ca_path = ca_file
-          end
+          ::Excon.ssl_verify_peer = !!ssl.fetch(:verify, true)
+          ::Excon.ssl_ca_path = ssl[:ca_file] if ssl[:ca_file]
         end
 
         resp = conn.request \
@@ -23,18 +17,12 @@ module Faraday
           :headers => env[:request_headers],
           :body    => env[:body]
 
-        env.update \
-          :status => resp.status.to_i,
-          :response_headers => {},
-          :body => resp.body
-
-        resp.headers.each do |key, value|
-          env[:response_headers][key.downcase] = value
-        end
+        env.update :status => resp.status.to_i, :body => resp.body
+        response_headers(env).update resp.headers
 
         @app.call env
-      rescue ::Excon::Errors::SocketError => e
-        raise Error::ConnectionFailed.new(e)
+      rescue ::Excon::Errors::SocketError
+        raise Error::ConnectionFailed, $!
       end
     end
   end