jnunemaker-httparty 0.1.4 → 0.1.5

data/History.txt

@@ -1,5 +1,10 @@
+== 0.1.5 2008-11-14
+* 2 major enhancements
+  * Refactored send request method out into its own object.
+  * Added :html format if you just want to do that.
+  
 == 0.1.4 2008-11-08
-* 2 major enhancements:
+* 3 major enhancements:
   * Removed some cruft
   * Added ability to follow redirects automatically and turn that off (Alex Vollmer)
 

data/Manifest.txt

@@ -13,13 +13,14 @@ examples/twitter.rb
 examples/whoismyrep.rb
 httparty.gemspec
 lib/httparty.rb
+lib/httparty/request.rb
 lib/httparty/version.rb
 script/console
 script/destroy
 script/generate
 script/txt2html
 setup.rb
-spec/hash_spec.rb
+spec/httparty/request_spec.rb
 spec/httparty_spec.rb
 spec/spec.opts
 spec/spec_helper.rb

data/examples/google.rb

@@ -4,6 +4,7 @@ require 'pp'
 
 class Google
   include HTTParty
+  format :html
 end
 
 # google.com redirects to www.google.com so this is live test for redirection

data/httparty.gemspec

@@ -1,28 +1,30 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{httparty}
-  s.version = "0.1.4"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2008-11-08}
+  s.date = %q{2008-11-14}
   s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
   s.email = ["nunemaker@gmail.com"]
   s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.txt"]
-  s.files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.txt", "Rakefile", "config/hoe.rb", "config/requirements.rb", "examples/aaws.rb", "examples/delicious.rb", "examples/google.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "httparty.gemspec", "lib/httparty.rb", "lib/httparty/version.rb", "script/console", "script/destroy", "script/generate", "script/txt2html", "setup.rb", "spec/hash_spec.rb", "spec/httparty_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/deployment.rake", "tasks/environment.rake", "tasks/website.rake", "website/css/common.css", "website/index.html"]
+  s.files = ["History.txt", "License.txt", "Manifest.txt", "PostInstall.txt", "README.txt", "Rakefile", "config/hoe.rb", "config/requirements.rb", "examples/aaws.rb", "examples/delicious.rb", "examples/google.rb", "examples/twitter.rb", "examples/whoismyrep.rb", "httparty.gemspec", "lib/httparty.rb", "lib/httparty/request.rb", "lib/httparty/version.rb", "script/console", "script/destroy", "script/generate", "script/txt2html", "setup.rb", "spec/httparty/request_spec.rb", "spec/httparty_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/deployment.rake", "tasks/environment.rake", "tasks/website.rake", "website/css/common.css", "website/index.html"]
   s.has_rdoc = true
   s.homepage = %q{http://httparty.rubyforge.org}
   s.post_install_message = %q{When you HTTParty, you must party hard!}
   s.rdoc_options = ["--main", "README.txt"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{httparty}
-  s.rubygems_version = %q{1.2.0}
+  s.rubygems_version = %q{1.3.1}
   s.summary = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 2
 
-    if current_version >= 3 then
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 2.1"])
       s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
     else

data/lib/httparty.rb

@@ -8,162 +8,88 @@ require 'active_support'
 directory = File.dirname(__FILE__)
 $:.unshift(directory) unless $:.include?(directory) || $:.include?(File.expand_path(directory))
 
+require 'httparty/request'
+
 module HTTParty
   class UnsupportedFormat < StandardError; end
   class RedirectionTooDeep < StandardError; end
+
+  AllowedFormats = {:xml => 'text/xml', :json => 'application/json', :html => 'text/html'}
   
   def self.included(base)
     base.extend ClassMethods
   end
   
-  AllowedFormats = {:xml => 'text/xml', :json => 'application/json'}
-  
-  module ClassMethods    
+  module ClassMethods
+    def default_options
+      @@default_options ||= {}
+    end
+
     #
     # Set an http proxy
     #
     #	class Twitter
     #	  include HTTParty
-    #	  http_proxy http://myProxy, 1080
+    #	  http_proxy 'http://myProxy', 1080
     # ....
     def http_proxy(addr=nil, port = nil)
-	   @http_proxyaddr = addr
-	   @http_proxyport = port
+      default_options[:http_proxyaddr] = addr
+      default_options[:http_proxyport] = port
     end
 
-    def base_uri(base_uri=nil)
-      return @base_uri unless base_uri
-      @base_uri = normalize_base_uri(base_uri)
+    def base_uri(uri=nil)
+      return default_options[:base_uri] unless uri
+      default_options[:base_uri] = normalize_base_uri(uri)
     end
-    
-    # Warning: This is not thread safe most likely and
-    # only works if you use one set of credentials. I
-    # leave it because it is convenient on some occasions.
+
     def basic_auth(u, p)
-      @auth = {:username => u, :password => p}
+      default_options[:basic_auth] = {:username => u, :password => p}
     end
     
-    # Updates the default query string parameters
-    # that should be appended to each request.
     def default_params(h={})
       raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
-      @default_params ||= {}
-      return @default_params if h.blank?
-      @default_params.merge!(h)
+      default_options[:default_params] ||= {}
+      default_options[:default_params].merge!(h)
     end
 
     def headers(h={})
       raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
-      @headers ||= {}
-      return @headers if h.blank?
-      @headers.merge!(h)
+      default_options[:headers] ||= {}
+      default_options[:headers].merge!(h)
     end
     
     def format(f)
       raise UnsupportedFormat, "Must be one of: #{AllowedFormats.keys.join(', ')}" unless AllowedFormats.key?(f)
-      @format = f
+      default_options[:format] = f
     end
     
-    # TODO: spec out this
     def get(path, options={})
-      send_request 'get', path, options
+      perform_request Net::HTTP::Get, path, options
     end
 
-    # TODO: spec out this    
     def post(path, options={})
-      send_request 'post', path, options
+      perform_request Net::HTTP::Post, path, options
     end
 
-    # TODO: spec out this    
     def put(path, options={})
-      send_request 'put', path, options
+      perform_request Net::HTTP::Put, path, options
     end
 
-    # TODO: spec out this    
     def delete(path, options={})
-      send_request 'delete', path, options
+      perform_request Net::HTTP::Delete, path, options
     end
-    
-    private
-      def http(uri) #:nodoc:
-        http = Net::HTTP.new(uri.host, uri.port, @http_proxyaddr, @http_proxyport)
-        http.use_ssl = (uri.port == 443)
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        http
-      end
-      
-      # FIXME: this method is doing way to much and needs to be split up
-      # options can be any or all of:
-      #   query       => hash of keys/values or a query string (foo=bar&baz=poo)
-      #   body        => hash of keys/values or a query string (foo=bar&baz=poo)
-      #   headers     => hash of headers to send request with
-      #   basic_auth  => :username and :password to use as basic http authentication (overrides @auth class instance variable)
-      # Raises exception Net::XXX (http error code) if an http error occured
-      def send_request(method, path, options={}) #:nodoc:
-        options = {:limit => 5}.merge(options)
-        options[:limit] = 0 if options.delete(:no_follow)
-        
-        raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
-        raise ArgumentError, 'only get, post, put and delete methods are supported' unless %w[get post put delete].include?(method.to_s)
-        raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
-        raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
-        
-        path           = URI.parse(path)
-        uri            = path.relative? ? URI.parse("#{base_uri}#{path}") : path
-        existing_query = uri.query ? "#{uri.query}&" : ''
-        uri.query      = if options[:query].blank?
-          existing_query + default_params.to_query
-        else
-          existing_query + (options[:query].is_a?(Hash) ? default_params.merge(options[:query]).to_query : options[:query])
-        end
-        
-        klass          = Net::HTTP.const_get method.to_s.downcase.capitalize
-        request        = klass.new(uri.request_uri)
-        request.body   = options[:body].is_a?(Hash) ? options[:body].to_query : options[:body] unless options[:body].blank?
-        basic_auth     = options.delete(:basic_auth) || @auth
-        request.initialize_http_header headers.merge(options[:headers] || {})
-        request.basic_auth(basic_auth[:username], basic_auth[:password]) if basic_auth
-        response       = http(uri).request(request)
-        @format      ||= format_from_mimetype(response['content-type'])
-        
-        case response
-        when Net::HTTPSuccess
-          parse_response(response.body)
-        when Net::HTTPRedirection
-          options[:limit] -= 1
-          send_request(method, response['location'], options)
-        else
-          response.instance_eval { class << self; attr_accessor :body_parsed; end }
-          begin; response.body_parsed = parse_response(response.body); rescue; end
-          response.error! # raises  exception corresponding to http error Net::XXX
-        end
 
-      end
-      
-      def parse_response(body) #:nodoc:
-        return nil if body.nil? or body.empty?
-        case @format
-        when :xml
-          Hash.from_xml(body)
-        when :json
-          ActiveSupport::JSON.decode(body)
-        else
-          body
-        end
+    private
+      def perform_request(http_method, path, options) #:nodoc:
+        Request.new(http_method, path, default_options.merge(options)).perform
       end
     
-      # Makes it so uri is sure to parse stuff like google.com with the http
+      # Makes it so uri is sure to parse stuff like google.com without the http
       def normalize_base_uri(url) #:nodoc:
         use_ssl = (url =~ /^https/) || url.include?(':443')
         url.chop! if url.ends_with?('/')
         url.gsub!(/^https?:\/\//i, '')
         "http#{'s' if use_ssl}://#{url}"
       end
-      
-      # Uses the HTTP Content-Type header to determine the format of the response
-      # It compares the MIME type returned to the types stored in the AllowedFormats hash
-      def format_from_mimetype(mimetype) #:nodoc:
-        AllowedFormats.each { |k, v| return k if mimetype.include?(v) }
-      end
   end
-end
+end

data/lib/httparty/request.rb

@@ -0,0 +1,104 @@
+module HTTParty
+  class Request
+    SupportedHTTPMethods = [Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete]
+
+    attr_accessor :http_method, :path, :options
+    
+    def initialize(http_method, path, options={})
+      self.http_method = http_method
+      self.path = path
+      self.options = {
+        :limit => options.delete(:no_follow) ? 0 : 5, 
+        :default_params => {},
+      }.merge(options.dup)
+    end
+
+    def path=(uri)
+      @path = URI.parse(uri)
+    end
+    
+    def uri
+      uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
+      uri.query = query_string(uri)
+      uri
+    end
+    
+    def perform
+      validate!
+      handle_response!(get_response(uri))
+    end
+
+    private
+      def http(uri) #:nodoc:
+        http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+        http.use_ssl = (uri.port == 443)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http
+      end
+      
+      def get_response(uri) #:nodoc:
+        request = http_method.new(uri.request_uri)
+        request.body = options[:body].is_a?(Hash) ? options[:body].to_query : options[:body] unless options[:body].blank?
+        request.initialize_http_header options[:headers]
+        request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password]) if options[:basic_auth]
+        response = http(uri).request(request)
+        options[:format] ||= format_from_mimetype(response['content-type'])
+        response
+      end
+      
+      def query_string(uri) #:nodoc:
+        query_string_parts = []
+        query_string_parts << uri.query unless uri.query.blank?
+
+        if options[:query].is_a?(Hash)
+          query_string_parts << options[:default_params].merge(options[:query]).to_query
+        else
+          query_string_parts << options[:default_params].to_query unless options[:default_params].blank?
+          query_string_parts << options[:query] unless options[:query].blank?
+        end
+        
+        query_string_parts.size > 0 ? query_string_parts.join('&') : nil
+      end
+      
+      # Raises exception Net::XXX (http error code) if an http error occured
+      def handle_response!(response) #:nodoc:
+        case response
+        when Net::HTTPSuccess
+          parse_response(response.body)
+        when Net::HTTPRedirection
+          options[:limit] -= 1
+          self.path = response['location']
+          perform
+        else
+          response.instance_eval { class << self; attr_accessor :body_parsed; end }
+          begin; response.body_parsed = parse_response(response.body); rescue; end
+          response.error! # raises  exception corresponding to http error Net::XXX
+        end
+      end
+      
+      def parse_response(body) #:nodoc:
+        return nil if body.nil? or body.empty?
+        case options[:format]
+        when :xml
+          Hash.from_xml(body)
+        when :json
+          ActiveSupport::JSON.decode(body)
+        else
+          body
+        end
+      end
+  
+      # Uses the HTTP Content-Type header to determine the format of the response
+      # It compares the MIME type returned to the types stored in the AllowedFormats hash
+      def format_from_mimetype(mimetype) #:nodoc:
+        AllowedFormats.each { |k, v| return k if mimetype.include?(v) }
+      end
+      
+      def validate! #:nodoc:
+        raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
+        raise ArgumentError, 'only get, post, put and delete methods are supported' unless SupportedHTTPMethods.include?(http_method)
+        raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
+        raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
+      end
+  end
+end

data/lib/httparty/version.rb

@@ -2,7 +2,7 @@ module HTTParty
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 4
+    TINY  = 5
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/httparty/request_spec.rb

@@ -0,0 +1,107 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe HTTParty::Request do
+  before do
+    @request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', :format => :xml)
+  end
+
+  describe 'http' do
+    it "should use ssl for port 443" do
+      @request.send(:http, URI.parse('https://api.foo.com/v1:443')).use_ssl?.should == true
+    end
+    
+    it 'should not use ssl for port 80' do
+      @request.send(:http, URI.parse('http://foobar.com')).use_ssl?.should == false
+    end
+  end
+
+  describe 'parsing responses' do
+    it 'should handle xml automatically' do
+      xml = %q[<books><book><id>1234</id><name>Foo Bar!</name></book></books>]
+      @request.options[:format] = :xml
+      @request.send(:parse_response, xml).should == {'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}}
+    end
+    
+    it 'should handle json automatically' do
+      json = %q[{"books": {"book": {"name": "Foo Bar!", "id": "1234"}}}]
+      @request.options[:format] = :json
+      @request.send(:parse_response, json).should == {'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}}
+    end
+  end
+
+  it "should not attempt to parse empty responses" do
+    http = Net::HTTP.new('localhost', 80)
+    @request.stub!(:http).and_return(http)
+    response = Net::HTTPNoContent.new("1.1", 204, "No content for you")
+    response.stub!(:body).and_return(nil)
+    http.stub!(:request).and_return(response)
+
+    @request.options[:format] = :xml
+    @request.perform.should be_nil
+
+    response.stub!(:body).and_return("")
+    @request.perform.should be_nil
+  end
+
+  describe "that respond with redirects" do
+    def setup_redirect
+      @http = Net::HTTP.new('localhost', 80)
+      @request.stub!(:http).and_return(@http)
+      @request.stub!(:uri).and_return(URI.parse("http://foo.com/foobar"))
+      @redirect = Net::HTTPFound.new("1.1", 302, "")
+      @redirect['location'] = '/foo'
+    end
+
+    def setup_ok_response
+      @ok = Net::HTTPOK.new("1.1", 200, "Content for you")
+      @ok.stub!(:body).and_return({"foo" => "bar"}.to_xml)
+      @http.should_receive(:request).and_return(@redirect, @ok)
+      @request.options[:format] = :xml
+    end
+
+    def setup_redirect_response
+      @http.stub!(:request).and_return(@redirect)
+    end
+
+    def setup_successful_redirect
+      setup_redirect
+      setup_ok_response
+    end
+
+    def setup_infinite_redirect
+      setup_redirect
+      setup_redirect_response
+    end
+
+    it "should handle redirects for GET transparently" do
+      setup_successful_redirect
+      @request.perform.should == {"hash" => {"foo" => "bar"}}
+    end
+
+    it "should handle redirects for POST transparently" do
+      setup_successful_redirect
+      @request.http_method = Net::HTTP::Post
+      @request.perform.should == {"hash" => {"foo" => "bar"}}
+    end
+
+    it "should handle redirects for DELETE transparently" do
+      setup_successful_redirect
+      @request.http_method = Net::HTTP::Delete
+      @request.perform.should == {"hash" => {"foo" => "bar"}}
+    end
+
+    it "should handle redirects for PUT transparently" do
+      setup_successful_redirect
+      @request.http_method = Net::HTTP::Put
+      @request.perform.should == {"hash" => {"foo" => "bar"}}
+    end
+
+    it "should prevent infinite loops" do
+      setup_infinite_redirect
+
+      lambda do
+        @request.perform
+      end.should raise_error(HTTParty::RedirectionTooDeep)
+    end
+  end
+end

data/spec/httparty_spec.rb

@@ -13,6 +13,10 @@ end
 describe HTTParty do
   
   describe "base uri" do
+    before do
+      Foo.base_uri('api.foo.com/v1')
+    end
+
     it "should have reader" do
       Foo.base_uri.should == 'http://api.foo.com/v1'
     end
@@ -65,19 +69,19 @@ describe HTTParty do
   describe "basic http authentication" do
     it "should work" do
       Foo.basic_auth 'foobar', 'secret'
-      Foo.instance_variable_get("@auth").should == {:username => 'foobar', :password => 'secret'}
+      Foo.default_options[:basic_auth].should == {:username => 'foobar', :password => 'secret'}
     end
   end
   
   describe "format" do
     it "should allow xml" do
       Foo.format :xml
-      Foo.instance_variable_get("@format").should == :xml
+      Foo.default_options[:format].should == :xml
     end
     
     it "should allow json" do
       Foo.format :json
-      Foo.instance_variable_get("@format").should == :json
+      Foo.default_options[:format].should == :json
     end
     
     it 'should not allow funky format' do
@@ -86,136 +90,31 @@ describe HTTParty do
       end.should raise_error(HTTParty::UnsupportedFormat)
     end
   end
-  
-  describe 'http' do
-    it "should use ssl for port 443" do
-      FooWithHttps.send(:http, URI.parse('https://api.foo.com/v1:443')).use_ssl?.should == true
-    end
-    
-    it 'should not use ssl for port 80' do
-      Foo.send(:http, URI.parse('http://foobar.com')).use_ssl?.should == false
-    end
-  end
-  
-  describe 'parsing responses' do
-    it 'should handle xml automatically' do
-      xml = %q[<books><book><id>1234</id><name>Foo Bar!</name></book></books>]
-      Foo.format :xml
-      Foo.send(:parse_response, xml).should == {'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}}
-    end
-    
-    it 'should handle json automatically' do
-      json = %q[{"books": {"book": {"name": "Foo Bar!", "id": "1234"}}}]
-      Foo.format :json
-      Foo.send(:parse_response, json).should == {'books' => {'book' => {'id' => '1234', 'name' => 'Foo Bar!'}}}
-    end
-  end
-  
-  describe "sending requests" do
-    it "should not work with request method other than get, post, put, delete" do
-      lambda do
-        Foo.send(:send_request, 'foo', '/foo')
-      end.should raise_error(ArgumentError)
-    end
-    
-    it 'should require that :headers is a hash if present' do
+
+  describe "with explicit override of automatic redirect handling" do
+
+    it "should fail with redirected GET" do
       lambda do
-        Foo.send(:send_request, 'get', '/foo', :headers => 'string')
-      end.should raise_error(ArgumentError)
+        Foo.get('/foo', :no_follow => true)
+      end.should raise_error(HTTParty::RedirectionTooDeep)
     end
-    
-    it 'should require that :basic_auth is a hash if present' do
+
+    it "should fail with redirected POST" do
       lambda do
-        Foo.send(:send_request, 'get', '/foo', :basic_auth => 'string')
-      end.should raise_error(ArgumentError)
+        Foo.post('/foo', :no_follow => true)
+      end.should raise_error(HTTParty::RedirectionTooDeep)
     end
 
-    it "should not attempt to parse empty responses" do
-      http = Net::HTTP.new('localhost', 80)
-      Foo.stub!(:http).and_return(http)
-      response = Net::HTTPNoContent.new("1.1", 204, "No content for you")
-      response.stub!(:body).and_return(nil)
-      http.stub!(:request).and_return(response)
-
-      Foo.headers.clear # clear out bogus settings from other specs
-      Foo.format :xml
-      Foo.send(:send_request, 'get', '/bar').should be_nil
-
-      response.stub!(:body).and_return("")
-      Foo.send(:send_request, 'get', 'bar').should be_nil
+    it "should fail with redirected DELETE" do
+      lambda do
+        Foo.delete('/foo', :no_follow => true)
+      end.should raise_error(HTTParty::RedirectionTooDeep)
     end
 
-    describe "that respond with redirects" do
-      def setup_http
-        @http = Net::HTTP.new('localhost', 80)
-        Foo.stub!(:http).and_return(@http)
-        @redirect = Net::HTTPFound.new("1.1", 302, "")
-        @redirect.stub!(:[]).with('location').and_return('/foo')
-        @ok = Net::HTTPOK.new("1.1", 200, "Content for you")
-        @ok.stub!(:body).and_return({"foo" => "bar"}.to_xml)
-        @http.should_receive(:request).and_return(@redirect, @ok)
-        Foo.headers.clear
-        Foo.format :xml
-      end
-
-      it "should handle redirects for GET transparently" do
-        setup_http
-        Foo.get('/foo/').should == {"hash" => {"foo" => "bar"}}
-      end
-
-      it "should handle redirects for POST transparently" do
-        setup_http
-        Foo.post('/foo/', {:foo => :bar}).should == {"hash" => {"foo" => "bar"}}
-      end
-
-      it "should handle redirects for DELETE transparently" do
-        setup_http
-        Foo.delete('/foo/').should == {"hash" => {"foo" => "bar"}}
-      end
-
-      it "should handle redirects for PUT transparently" do
-        setup_http
-        Foo.put('/foo/').should == {"hash" => {"foo" => "bar"}}
-      end
-
-      it "should prevent infinite loops" do
-        http = Net::HTTP.new('localhost', 80)
-        Foo.stub!(:http).and_return(http)
-        redirect = Net::HTTPFound.new("1.1", "302", "Look, over there!")
-        redirect.stub!(:[]).with('location').and_return('/foo')
-        http.stub!(:request).and_return(redirect)
-
-        lambda do
-          Foo.send(:send_request, 'get', '/foo')
-        end.should raise_error(HTTParty::RedirectionTooDeep)
-      end
-
-      describe "with explicit override of automatic redirect handling" do
-
-        it "should fail with redirected GET" do
-          lambda do
-            Foo.get('/foo', :no_follow => true)
-          end.should raise_error(HTTParty::RedirectionTooDeep)
-        end
-
-        it "should fail with redirected POST" do
-          lambda do
-            Foo.post('/foo', :no_follow => true)
-          end.should raise_error(HTTParty::RedirectionTooDeep)
-        end
-
-        it "should fail with redirected DELETE" do
-          lambda do
-            Foo.delete('/foo', :no_follow => true)
-          end
-        end
-
-        it "should fail with redirected PUT" do
-          lambda do
-            Foo.put('/foo', :no_follow => true)
-          end
-        end
-      end
+    it "should fail with redirected PUT" do
+      lambda do
+        Foo.put('/foo', :no_follow => true)
+      end.should raise_error(HTTParty::RedirectionTooDeep)
     end
   end
-end
+end

data/spec/spec.opts

@@ -1 +1,3 @@
---colour
+--format
+  progress
+--colour

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jnunemaker-httparty
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-08 00:00:00 -08:00
+date: 2008-11-14 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,13 +59,14 @@ files:
 - examples/whoismyrep.rb
 - httparty.gemspec
 - lib/httparty.rb
+- lib/httparty/request.rb
 - lib/httparty/version.rb
 - script/console
 - script/destroy
 - script/generate
 - script/txt2html
 - setup.rb
-- spec/hash_spec.rb
+- spec/httparty/request_spec.rb
 - spec/httparty_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb