faraday 0.4.6 → 0.5.0

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,7 +1,31 @@
 module Faraday
   module Error
-    class ClientError      < 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.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/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/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/test/adapters/live_test.rb

@@ -3,7 +3,10 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'helper'))
 if Faraday::TestCase::LIVE_SERVER
   module Adapters
     class LiveTest < Faraday::TestCase
-      (Faraday::Adapter.all_loaded_constants + [:default]).each do |adapter|
+      loaded_adapters  = Faraday::Adapter.all_loaded_constants
+      loaded_adapters -= [Faraday::Adapter::ActionDispatch]
+      loaded_adapters << :default
+      loaded_adapters.each do |adapter|
         define_method "test_#{adapter}_GET_retrieves_the_response_body" do
           assert_equal 'hello world', create_connection(adapter).get('hello_world').body
         end
@@ -39,6 +42,15 @@ if Faraday::TestCase::LIVE_SERVER
           assert_equal 'text/html', create_connection(adapter).post('echo_name').headers['content-type']
         end
 
+        define_method "test_#{adapter}_POST_sends_files" do
+          name = File.join(File.dirname(__FILE__), '..', 'live_server.rb')
+          resp = create_connection(adapter).post do |req|
+            req.url 'file'
+            req.body = {'uploaded_file' => Faraday::UploadIO.new(name, 'text/x-ruby')}
+          end
+          assert_equal "file live_server.rb text/x-ruby", resp.body
+        end
+
         # http://github.com/toland/patron/issues/#issue/9
         if ENV['FORCE'] || adapter != Faraday::Adapter::Patron
           define_method "test_#{adapter}_PUT_send_url_encoded_params" do
@@ -62,22 +74,19 @@ if Faraday::TestCase::LIVE_SERVER
           end
         end
 
-        # http://github.com/pauldix/typhoeus/issues#issue/7
-        if ENV['FORCE'] || adapter != Faraday::Adapter::Typhoeus
-          define_method "test_#{adapter}_HEAD_send_url_encoded_params" do
-            resp = create_connection(adapter).head do |req|
-              req.url 'hello', 'name' => 'zack'
-            end
-            assert_equal 'text/html', resp.headers['content-type']
+        define_method "test_#{adapter}_HEAD_send_url_encoded_params" do
+          resp = create_connection(adapter).head do |req|
+            req.url 'hello', 'name' => 'zack'
           end
+          assert_equal 'text/html', resp.headers['content-type']
+        end
 
-          define_method "test_#{adapter}_HEAD_retrieves_no_response_body" do
-            assert_equal '', create_connection(adapter).head('hello_world').body.to_s
-          end
+        define_method "test_#{adapter}_HEAD_retrieves_no_response_body" do
+          assert_equal '', create_connection(adapter).head('hello_world').body.to_s
+        end
 
-          define_method "test_#{adapter}_HEAD_retrieves_the_response_headers" do
-            assert_equal 'text/html', create_connection(adapter).head('hello_world').headers['content-type']
-          end
+        define_method "test_#{adapter}_HEAD_retrieves_the_response_headers" do
+          assert_equal 'text/html', create_connection(adapter).head('hello_world').headers['content-type']
         end
 
         define_method "test_#{adapter}_DELETE_retrieves_the_response_headers" do
@@ -95,7 +104,7 @@ if Faraday::TestCase::LIVE_SERVER
           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