httparty 0.1.3 → 0.1.5

data/History.txt

@@ -1,3 +1,13 @@
+== 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
+* 3 major enhancements:
+  * Removed some cruft
+  * Added ability to follow redirects automatically and turn that off (Alex Vollmer)
+
 == 0.1.3 2008-08-22
 
 * 3 major enhancements:

data/Manifest.txt

@@ -8,19 +8,19 @@ 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/core_ext.rb
-lib/httparty/core_ext/hash.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/README.txt

@@ -43,6 +43,20 @@ That works and all but what if you don't want to embed your username and passwor
 	
 	Twitter.new('username', 'password').post("It's an HTTParty and everyone is invited!")
 
+=== REQUEST OPTIONS
+
+Each of the HTTP method (get, post, put and delete) each take a hash of options.
+The following keys can be specified in the options:
+
+headers::       A <tt>Hash</tt> of header key/value pairs
+query::         A <tt>Hash</tt> of query key/value pairs
+body::          The body of the request. If it's a <tt>Hash</tt>, it is
+                converted into query-string format, otherwise it is sent
+                as-is.
+basic_auth::    A <tt>Hash</tt> containing keys for <tt>:username</tt> and
+                <tt>:password</tt>.
+no_follow::     Turns off automatic redirect following
+
 == REQUIREMENTS:
 
 * Active Support >= 2.1

data/Rakefile

@@ -1,4 +1,11 @@
 require 'config/requirements'
 require 'config/hoe' # setup Hoe + all gem configuration
+require "spec/rake/spectask"
 
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList["spec/**/*_spec.rb"]
+end

data/examples/google.rb

@@ -0,0 +1,16 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Google
+  include HTTParty
+  format :html
+end
+
+# google.com redirects to www.google.com so this is live test for redirection
+pp Google.get('http://google.com')
+
+puts '', '*'*70, ''
+
+# check that ssl is requesting right
+pp Google.get('https://www.google.com')

data/httparty.gemspec

@@ -1,33 +1,38 @@
+# -*- encoding: utf-8 -*-
+
 Gem::Specification.new do |s|
   s.name = %q{httparty}
-  s.version = "0.1.3"
+  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-08-22}
+  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/twitter.rb", "examples/whoismyrep.rb", "httparty.gemspec", "lib/httparty.rb", "lib/httparty/core_ext.rb", "lib/httparty/core_ext/hash.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
       s.add_dependency(%q<activesupport>, [">= 2.1"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 2.1"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
   end
 end

data/lib/httparty.rb

@@ -5,160 +5,91 @@ require 'ostruct'
 require 'rubygems'
 require 'active_support'
 
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+directory = File.dirname(__FILE__)
+$:.unshift(directory) unless $:.include?(directory) || $:.include?(File.expand_path(directory))
+
+require 'httparty/request'
 
-dir = File.expand_path(File.join(File.dirname(__FILE__), 'httparty'))
-require dir + '/core_ext'
-  
 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
-      # don't want this to ever end with /
-      base_uri = base_uri.ends_with?('/') ? base_uri.chop : 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:
-        if @http.blank?
-          @http = Net::HTTP.new(uri.host, uri.port, @http_proxyaddr, @http_proxyport)
-          @http.use_ssl = (uri.port == 443)
-          # so we can avoid ssl warnings
-          @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-        @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:
-        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)
-        uri            = URI.parse("#{base_uri}#{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] || {})
-        # note to self: self, do not put basic auth above headers because it removes basic auth
-        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)
-        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:
-        case @format
-        when :xml
-          Hash.from_xml(body)
-        when :json
-          ActiveSupport::JSON.decode(body)
-        else
-          # just return the response if no format 
-          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
-      def normalize_base_uri(str) #:nodoc:
-        str =~ /^https?:\/\// ? str : "http#{'s' if str.include?(':443')}://#{str}"
-      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) }
+      # 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
   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  = 3
+    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,11 +13,15 @@ end
 describe HTTParty do
   
   describe "base uri" do
-    it "should be gettable" 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
     
-    it 'should be setable' do
+    it 'should have writer' do
       Foo.base_uri('http://api.foobar.com')
       Foo.base_uri.should == 'http://api.foobar.com'
     end
@@ -28,7 +32,13 @@ describe HTTParty do
     end
     
     it "should add https if not present for ssl requests" do
-      FooWithHttps.base_uri.should == 'https://api.foo.com/v1:443'
+      Foo.base_uri('api.foo.com/v1:443')
+      Foo.base_uri.should == 'https://api.foo.com/v1:443'
+    end
+    
+    it "should not remove https for ssl requests" do
+      Foo.base_uri('https://api.foo.com/v1:443')
+      Foo.base_uri.should == 'https://api.foo.com/v1:443'
     end
   end
   
@@ -59,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
@@ -80,66 +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 "deriving format from path" do
-    it "should work if there is extension and extension is an allowed format" do
-      %w[xml json].each do |ext|
-        Foo.send(:format_from_path, "/foo/bar.#{ext}").should == ext
-      end
-    end
-    
-    it "should NOT work if there is extension but extention is not allow format" do
-      Foo.send(:format_from_path, '/foo/bar.php').should == nil
-    end
-    
-    it 'should NOT work if there is no extension' do
-      ['', '.'].each do |ext|
-        Foo.send(:format_from_path, "/foo/bar#{ext}").should == nil
-      end
-    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!'}}}
+
+  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
-  end
-  
-  describe "sending requests" do
-    it "should not work with request method other than get, post, put, delete" do
+
+    it "should fail with redirected POST" do
       lambda do
-        Foo.send(:send_request, 'foo', '/foo')
-      end.should raise_error(ArgumentError)
+        Foo.post('/foo', :no_follow => true)
+      end.should raise_error(HTTParty::RedirectionTooDeep)
     end
-    
-    it 'should require that :headers is a hash if present' do
+
+    it "should fail with redirected DELETE" do
       lambda do
-        Foo.send(:send_request, 'get', '/foo', :headers => 'string')
-      end.should raise_error(ArgumentError)
+        Foo.delete('/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 PUT" do
       lambda do
-        Foo.send(:send_request, 'get', '/foo', :basic_auth => 'string')
-      end.should raise_error(ArgumentError)
+        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: httparty
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors: 
 - John Nunemaker
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-22 00:00:00 -04:00
+date: 2008-11-14 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "2.1"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
 description: Makes http fun! Also, makes consuming restful web services dead easy.
 email: 
 - nunemaker@gmail.com
@@ -46,19 +56,19 @@ files:
 - 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/core_ext.rb
-- lib/httparty/core_ext/hash.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
@@ -90,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: httparty
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Makes http fun! Also, makes consuming restful web services dead easy.

data/lib/httparty/core_ext.rb

@@ -1,2 +0,0 @@
-dir = File.expand_path(File.join(File.dirname(__FILE__), 'core_ext'))
-require File.join(dir, 'hash')

data/lib/httparty/core_ext/hash.rb

@@ -1,21 +0,0 @@
-module HTTParty
-  module CoreExt
-    module HashConversions
-      def to_struct
-        o = OpenStruct.new
-        self.each do |k, v|
-          # if id, we create an accessor so we don't get warning about id deprecation
-          if k.to_s == 'id'
-            o.class.class_eval "attr_accessor :id"
-            o.id = v
-          else
-            o.send("#{k}=", v.is_a?(Hash) ? v.to_struct : v)
-          end
-        end
-        o
-      end
-    end
-  end
-end
-
-Hash.send :include, HTTParty::CoreExt::HashConversions

data/spec/hash_spec.rb

@@ -1,11 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe HTTParty::CoreExt::HashConversions do
-  it "should convert hash to struct" do
-    {'foo' => 'bar'}.to_struct.should == OpenStruct.new(:foo => 'bar')
-  end
-  
-  it 'should convert nested hash to struct' do
-    {'foo' => {'bar' => 'baz'}}.to_struct.should == OpenStruct.new(:foo => OpenStruct.new(:bar => 'baz'))
-  end
-end