faraday 0.6.1 → 0.7.0

data/Gemfile

@@ -5,14 +5,14 @@ source "http://rubygems.org"
 # and rake tasks are available in development mode:
 group :development, :test do
   gem 'patron', '~> 0.4', :platforms => :ruby
-  gem 'sinatra', '~> 1.1'
+  gem 'sinatra', '~> 1.2'
   gem 'typhoeus', '~> 0.2', :platforms => :ruby
-  gem 'excon', '~> 0.5.8'
+  gem 'excon', '~> 0.6'
   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 'activesupport', '~> 2.3', :require => nil, :platforms => [:ruby_18, :jruby]
   gem 'yajl-ruby', :require => 'yajl', :platforms => :ruby_19
 end
 

data/Rakefile

@@ -1,5 +1,5 @@
-require 'rubygems'
-require 'rake'
+#!/usr/bin/env rake
+
 require 'date'
 
 #############################################################################

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.6.1'
-  s.date              = '2011-04-13'
+  s.version           = '0.7.0'
+  s.date              = '2011-05-10'
   s.rubyforge_project = 'faraday'
 
   ## Make sure your summary is short. The description may be as long

data/lib/faraday.rb

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

data/lib/faraday/adapter/patron.rb

@@ -12,11 +12,8 @@ module Faraday
         session = ::Patron::Session.new
 
         response = begin
-          if Connection::METHODS_WITH_BODIES.include? env[:method]
-            session.send(env[:method], env[:url].to_s, env[:body].to_s, env[:request_headers])
-          else
-            session.send(env[:method], env[:url].to_s, env[:request_headers])
-          end
+          data = Connection::METHODS_WITH_BODIES.include?(env[:method]) ? env[:body].to_s : nil
+          session.request(env[:method], env[:url].to_s, env[:request_headers], :data => data)
         rescue Errno::ECONNREFUSED
           raise Error::ConnectionFailed, $!
         end
@@ -26,5 +23,11 @@ module Faraday
         @app.call env
       end
     end
+
+    # HAX: helps but doesn't work completely
+    # https://github.com/toland/patron/issues/34
+    valid_actions = ::Patron::Request::VALID_ACTIONS
+    valid_actions << :patch unless valid_actions.include? :patch
+    valid_actions << :options unless valid_actions.include? :options
   end
 end

data/lib/faraday/builder.rb

@@ -12,6 +12,9 @@ module Faraday
       new { |builder| yield builder }
     end
 
+    # Error raised when trying to modify the stack after calling `lock!`
+    class StackLocked < RuntimeError; end
+
     # borrowed from ActiveSupport::Dependencies::Reference &
     # ActionDispatch::MiddlewareStack::Middleware
     class Handler
@@ -55,6 +58,7 @@ module Faraday
     end
 
     def build(options = {})
+      raise_if_locked
       @handlers.clear unless options[:keep]
       yield self if block_given?
     end
@@ -76,7 +80,17 @@ module Faraday
       @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
     end
 
+    # Locks the middleware stack to ensure no further modifications are possible.
+    def lock!
+      @handlers.freeze
+    end
+
+    def locked?
+      @handlers.frozen?
+    end
+
     def use(klass, *args)
+      raise_if_locked
       block = block_given? ? Proc.new : nil
       @handlers << self.class::Handler.new(klass, *args, &block)
     end
@@ -99,6 +113,7 @@ module Faraday
     ## methods to push onto the various positions in the stack:
 
     def insert(index, *args, &block)
+      raise_if_locked
       index = assert_index(index)
       handler = self.class::Handler.new(*args, &block)
       @handlers.insert(index, handler)
@@ -112,17 +127,23 @@ module Faraday
     end
 
     def swap(index, *args, &block)
+      raise_if_locked
       index = assert_index(index)
       @handlers.delete_at(index)
       insert(index, *args, &block)
     end
 
     def delete(handler)
+      raise_if_locked
       @handlers.delete(handler)
     end
 
     private
 
+    def raise_if_locked
+      raise StackLocked, "can't modify middleware stack after making a request" if locked?
+    end
+
     def use_symbol(mod, key, *args)
       block = block_given? ? Proc.new : nil
       use(mod.lookup_module(key), *args, &block)

data/lib/faraday/connection.rb

@@ -4,10 +4,10 @@ require 'base64'
 
 module Faraday
   class Connection
-    include Addressable, Faraday::Utils
+    include Addressable
 
-    METHODS = Set.new [:get, :post, :put, :delete, :head]
-    METHODS_WITH_BODIES = Set.new [:post, :put]
+    METHODS = Set.new [:get, :post, :put, :delete, :head, :patch, :options]
+    METHODS_WITH_BODIES = Set.new [:post, :put, :patch, :options]
 
     attr_accessor :host, :port, :scheme, :params, :headers, :parallel_manager
     attr_reader   :path_prefix, :builder, :options, :ssl
@@ -22,15 +22,17 @@ module Faraday
         options = url
         url     = options[:url]
       end
-      @headers          = Headers.new
-      @params           = {}
+      @headers          = Utils::Headers.new
+      @params           = Utils::ParamsHash.new
       @options          = options[:request] || {}
       @ssl              = options[:ssl]     || {}
       @parallel_manager = options[:parallel]
+
       self.url_prefix = url if url
       proxy(options[:proxy])
-      merge_params  @params,  options[:params]  if options[:params]
-      merge_headers @headers, options[:headers] if options[:headers]
+
+      @params.update options[:params]   if options[:params]
+      @headers.update options[:headers] if options[:headers]
 
       if block_given?
         @builder = Builder.create { |b| yield b }
@@ -59,6 +61,25 @@ module Faraday
       @builder.build(options, &block)
     end
 
+    # The "rack app" wrapped in middleware. All requests are sent here.
+    #
+    # The builder is responsible for creating the app object. After this,
+    # the builder gets locked to ensure no further modifications are made
+    # to the middleware stack.
+    #
+    # Returns an object that responds to `call` and returns a Response.
+    def app
+      @app ||= begin
+        builder.lock!
+        builder.to_app(lambda { |env|
+          # the inner app that creates and returns the Response object
+          response = Response.new
+          response.finish(env) unless env[:parallel_manager]
+          env[:response] = response
+        })
+      end
+    end
+
     def get(url = nil, headers = nil)
       block = block_given? ? Proc.new : nil
       run_request(:get, url, nil, headers, &block)
@@ -74,6 +95,11 @@ module Faraday
       run_request(:put, url, body, headers, &block)
     end
 
+    def patch(url = nil, body = nil, headers = nil)
+      block = block_given? ? Proc.new : nil
+      run_request(:patch, url, body, headers, &block)
+    end
+
     def head(url = nil, headers = nil)
       block = block_given? ? Proc.new : nil
       run_request(:head, url, nil, headers, &block)
@@ -145,12 +171,11 @@ module Faraday
       self.host        = uri.host
       self.port        = uri.port
       self.path_prefix = uri.path
-      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
+
+      @params.merge_query(uri.query)
+      basic_auth(uri.user, uri.password) if uri.user && uri.password
+
+      uri
     end
 
     # Ensures that the path prefix always has a leading / and no trailing /
@@ -167,12 +192,15 @@ module Faraday
         raise ArgumentError, "unknown http method: #{method}"
       end
 
-      Request.run(self, method) do |req|
+      request = Request.create(method) do |req|
         req.url(url)                if url
         req.headers.update(headers) if headers
         req.body = body             if body
         yield req if block_given?
       end
+
+      env = request.to_env(self)
+      self.app.call(env)
     end
 
     # Takes a relative url for a request and combines it with the defaults
@@ -186,7 +214,7 @@ module Faraday
     #   conn.build_url("nigiri?page=2")      # => https://sushi.com/api/nigiri?token=abc&page=2
     #   conn.build_url("nigiri", :page => 2) # => https://sushi.com/api/nigiri?token=abc&page=2
     #
-    def build_url(url, params = nil)
+    def build_url(url, extra_params = nil)
       uri          = URI.parse(url.to_s)
       if @path_prefix && uri.path !~ /^\//
         uri.path = "#{@path_prefix.size > 1 ? @path_prefix : nil}/#{uri.path}"
@@ -194,7 +222,11 @@ module Faraday
       uri.host   ||= @host
       uri.port   ||= @port
       uri.scheme ||= @scheme
-      replace_query(uri, params)
+
+      params = @params.dup.merge_query(uri.query)
+      params.update extra_params if extra_params
+      uri.query = params.empty? ? nil : params.to_query
+
       uri
     end
 
@@ -202,18 +234,6 @@ module Faraday
       self.class.new(build_url(''), :headers => headers.dup, :params => params.dup, :builder => builder.dup)
     end
 
-    def replace_query(uri, params)
-      url_params = @params.dup
-      if uri.query && !uri.query.empty?
-        merge_params(url_params, parse_query(uri.query))
-      end
-      if params && !params.empty?
-        merge_params(url_params, params)
-      end
-      uri.query = url_params.empty? ? nil : build_query(url_params)
-      uri
-    end
-
     def proxy_arg_to_uri(arg)
       case arg
         when String then URI.parse(arg)

data/lib/faraday/request.rb

@@ -22,16 +22,18 @@ module Faraday
       :url_encoded => :UrlEncoded,
       :multipart   => :Multipart
 
-    def self.run(connection, request_method)
-      req = create
-      yield req if block_given?
-      req.run(connection, request_method)
+    attr_reader :method
+
+    def self.create(request_method)
+      new(request_method).tap do |request|
+        yield request if block_given?
+      end
     end
 
-    def self.create
-      req = new(nil, {}, {}, nil)
-      yield req if block_given?
-      req
+    def initialize(request_method)
+      @method = request_method
+      self.params = {}
+      self.headers = {}
     end
 
     def url(path, params = {})
@@ -63,13 +65,11 @@ module Faraday
     #     :user       - Proxy server username
     #     :password   - Proxy server password
     # :ssl - Hash of options for configuring SSL requests.
-    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)
+    def to_env(connection)
+      env_params  = connection.params.merge(params)
+      env_headers = connection.headers.merge(headers)
 
-      { :method           => request_method,
+      { :method           => method,
         :body             => body,
         :url              => connection.build_url(path, env_params),
         :request_headers  => env_headers,
@@ -77,15 +77,5 @@ module Faraday
         :request          => connection.options.merge(:proxy => connection.proxy),
         :ssl              => connection.ssl}
     end
-
-    def run(connection, request_method)
-      app = lambda { |env|
-        response = Response.new
-        response.finish(env) unless env[:parallel_manager]
-        env[:response] = response
-      }
-      env = to_env_hash(connection, request_method)
-      connection.builder.to_app(app).call(env)
-    end
   end
 end

data/lib/faraday/utils.rb

@@ -1,4 +1,5 @@
 require 'rack/utils'
+
 module Faraday
   module Utils
     include Rack::Utils
@@ -44,8 +45,65 @@ module Faraday
       end
     end
 
-    # Make Rack::Utils build_query method public.
-    public :build_query
+    # hash with stringified keys
+    class ParamsHash < Hash
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def include?(key)
+        super(convert_key(key))
+      end
+
+      alias_method :has_key?, :include?
+      alias_method :member?, :include?
+      alias_method :key?, :include?
+
+      def update(params)
+        params.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+      alias_method :merge!, :update
+
+      def merge(params)
+        dup.update(params)
+      end
+
+      def replace(other)
+        clear
+        update(other)
+      end
+
+      def merge_query(query)
+        if query && !query.empty?
+          update Utils.parse_query(query)
+        end
+        self
+      end
+
+      def to_query
+        Utils.build_query(self)
+      end
+
+      private
+
+      def convert_key(key)
+        key.to_s
+      end
+    end
+
+    # Make Rack::Utils methods public.
+    public :build_query, :parse_query
 
     # Override Rack's version since it doesn't handle non-String values
     def build_nested_query(value, prefix = nil)
@@ -72,20 +130,6 @@ module Faraday
       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
-    def merge_headers(existing_headers, new_headers)
-      new_headers.each do |key, value|
-        existing_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 : "/") +

data/test/adapters/live_test.rb

@@ -67,8 +67,8 @@ else
           assert_equal "file live_test.rb text/x-ruby", resp.body
         end unless :default == adapter # isn't configured for multipart
 
-        # http://github.com/toland/patron/issues/#issue/9
-        if ENV['FORCE'] || adapter != Faraday::Adapter::Patron
+        # https://github.com/toland/patron/issues/9
+        if ENV['FORCE'] || %[Faraday::Adapter::Patron] != adapter.to_s
           define_method "test_#{adapter}_PUT_send_url_encoded_params" do
             resp = create_connection(adapter).put do |req|
               req.url 'echo_name'
@@ -90,6 +90,21 @@ else
           end
         end
 
+        # https://github.com/toland/patron/issues/34
+        unless %w[Faraday::Adapter::Patron Faraday::Adapter::EMSynchrony].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
+        end
+
         define_method "test_#{adapter}_HEAD_send_url_encoded_params" do
           resp = create_connection(adapter).head do |req|
             req.url 'hello', 'name' => 'zack'
@@ -158,19 +173,19 @@ else
 
       def create_connection(adapter)
         if adapter == :default
-          Faraday.default_connection.tap do |conn|
-            conn.url_prefix = LIVE_SERVER
-            conn.headers['X-Faraday-Adapter'] = adapter.to_s
-          end
+          builder_block = nil
         else
-          Faraday::Connection.new LIVE_SERVER, :headers => {'X-Faraday-Adapter' => adapter.to_s} do |b|
+          builder_block = Proc.new do |b|
             b.request :multipart
             b.request :url_encoded
             b.use adapter
           end
-        end.tap do |conn|
-          target = conn.builder.handlers.last
-          conn.builder.insert_before target, Faraday::Response::RaiseError
+        end
+        
+        Faraday::Connection.new(LIVE_SERVER, &builder_block).tap do |conn|
+          conn.headers['X-Faraday-Adapter'] = adapter.to_s
+          adapter_handler = conn.builder.handlers.last
+          conn.builder.insert_before adapter_handler, Faraday::Response::RaiseError
         end
       end
 

data/test/connection_test.rb

@@ -38,18 +38,22 @@ class TestConnection < Faraday::TestCase
 
   def test_initialize_stores_default_params_from_options
     conn = Faraday::Connection.new :params => {:a => 1}
-    assert_equal 1, conn.params['a']
+    assert_equal({'a' => 1}, conn.params)
   end
 
   def test_initialize_stores_default_params_from_uri
-    conn = Faraday::Connection.new "http://sushi.com/fish?a=1", :params => {'b' => '2'}
-    assert_equal '1', conn.params['a']
-    assert_equal '2', conn.params['b']
+    conn = Faraday::Connection.new "http://sushi.com/fish?a=1"
+    assert_equal({'a' => '1'}, conn.params)
+  end
+
+  def test_initialize_stores_default_params_from_uri_and_options
+    conn = Faraday::Connection.new "http://sushi.com/fish?a=1&b=2", :params => {'a' => 3}
+    assert_equal({'a' => 3, 'b' => '2'}, conn.params)
   end
 
   def test_initialize_stores_default_headers_from_options
-    conn = Faraday::Connection.new :headers => {:a => 1}
-    assert_equal '1', conn.headers['A']
+    conn = Faraday::Connection.new :headers => {:user_agent => 'Faraday'}
+    assert_equal 'Faraday', conn.headers['User-agent']
   end
 
   def test_basic_auth_sets_authorization_header
@@ -152,21 +156,21 @@ class TestConnection < Faraday::TestCase
   def test_build_url_mashes_default_and_given_params_together
     conn = Faraday::Connection.new 'http://sushi.com/api?token=abc', :params => {'format' => 'json'}
     url = conn.build_url("nigiri?page=1", :limit => 5)
-    assert_match /limit=5/,      url.query
-    assert_match /page=1/,       url.query
-    assert_match /format=json/,  url.query
-    assert_match /token=abc/,    url.query
+    assert_equal %w[format=json limit=5 page=1 token=abc], url.query.split('&').sort
   end
 
   def test_build_url_overrides_default_params_with_given_params
     conn = Faraday::Connection.new 'http://sushi.com/api?token=abc', :params => {'format' => 'json'}
     url = conn.build_url("nigiri?page=1", :limit => 5, :token => 'def', :format => 'xml')
-    assert_match /limit=5/,        url.query
-    assert_match /page=1/,         url.query
-    assert_match /format=xml/,     url.query
-    assert_match /token=def/,      url.query
-    assert_no_match /format=json/, url.query
-    assert_no_match /token=abc/,   url.query
+    assert_equal %w[format=xml limit=5 page=1 token=def], url.query.split('&').sort
+  end
+
+  def test_default_params_hash_has_indifferent_access
+    conn = Faraday::Connection.new :params => {'format' => 'json'}
+    assert conn.params.has_key?(:format)
+    conn.params[:format] = 'xml'
+    url = conn.build_url("")
+    assert_equal %w[format=xml], url.query.split('&').sort
   end
 
   def test_build_url_parses_url
@@ -222,10 +226,8 @@ class TestConnection < Faraday::TestCase
 
   def test_params_to_query_converts_hash_of_params_to_uri_escaped_query_string
     conn = Faraday::Connection.new
-    class << conn
-      public :build_query
-    end
-    assert_equal "a%5Bb%5D=1%20%2B%202", conn.build_query('a[b]' => '1 + 2')
+    url = conn.build_url('', 'a[b]' => '1 + 2')
+    assert_equal "a%5Bb%5D=1%20%2B%202", url.query
   end
 
   def test_dups_connection_object

data/test/env_test.rb

@@ -47,10 +47,10 @@ class EnvTest < Faraday::TestCase
   end
 
   def env_for(connection)
-    env_setup = Faraday::Request.create do |req|
+    env_setup = Faraday::Request.create(:get) do |req|
       yield req
     end
-    env_setup.to_env_hash(connection, :get)
+    env_setup.to_env(connection)
   end
 end
 

data/test/live_server.rb

@@ -20,18 +20,22 @@ post '/file' do
   end
 end
 
-%w[get post].each do |method|
+[:get, :post].each do |method|
   send(method, '/hello') do
     "hello #{params[:name]}"
   end
 end
 
-%w[post put].each do |method|
-  send(method, '/echo_name') do
+%w[POST PUT PATCH].each do |http_method|
+  settings.send(:route, http_method, '/echo_name') do
     params[:name].inspect
   end
 end
 
+options '/options' do
+  'hi'
+end
+
 delete '/delete_with_json' do
   %/{"deleted":true}/
 end

data/test/middleware_stack_test.rb

@@ -26,8 +26,6 @@ class MiddlewareStackTest < Faraday::TestCase
 
   def test_allows_rebuilding
     build_stack Apple
-    assert_handlers %w[Apple]
-
     build_stack Orange
     assert_handlers %w[Orange]
   end
@@ -67,6 +65,28 @@ class MiddlewareStackTest < Faraday::TestCase
     assert_handlers %w[Orange]
   end
 
+  def test_stack_is_locked_after_making_requests
+    build_stack Apple
+    assert !@builder.locked?
+    @conn.get('/')
+    assert @builder.locked?
+
+    assert_raises Faraday::Builder::StackLocked do
+      @conn.use Orange
+    end
+  end
+
+  def test_duped_stack_is_unlocked
+    build_stack Apple
+    assert !@builder.locked?
+    @builder.lock!
+    assert @builder.locked?
+
+    duped_connection = @conn.dup
+    assert_equal @builder, duped_connection.builder
+    assert !duped_connection.builder.locked?
+  end
+
   private
 
   # make a stack with test adapter that reflects the order of middleware

metadata

@@ -2,7 +2,7 @@
 name: faraday
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors: 
 - Rick Olson
@@ -10,7 +10,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-13 00:00:00 Z
+date: 2011-05-10 00:00:00 -07:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -106,6 +107,7 @@ files:
 - test/middleware_stack_test.rb
 - test/request_middleware_test.rb
 - test/response_middleware_test.rb
+has_rdoc: true
 homepage: http://github.com/technoweenie/faraday
 licenses: []
 
@@ -129,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: faraday
-rubygems_version: 1.7.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 2
 summary: HTTP/REST API client library.
@@ -143,4 +145,3 @@ test_files:
 - test/middleware_stack_test.rb
 - test/request_middleware_test.rb
 - test/response_middleware_test.rb
-has_rdoc: