jugend-httparty 0.5.2.2 → 0.5.2.3

data/History

@@ -1,30 +1,12 @@
-== 0.5.3.4
-  * Update gem name to jugend-httparty
-  
-== 0.5.3.3
-  * Remove RubyforgeTasks
-  
-== 0.5.3.2
-  * Remove deprecated rubyforge gem push
-  
-== 0.5.3.1
-  * Update Pathname initialization to support earlier version of ruby (<=1.8.4)
+== 0.5.2.3
+  * Repackage gem, old gem contains master branch files
 
-== 0.5.3 (master)
-* major enhancements
-  * Digest Auth (bartiaco, sbecker, gilles, and aaronrussell)
-  * Maintain HTTP method across redirects (bartiaco and sbecker)
-  * HTTParty::Response#response returns the Net::HTTPResponse object
-  * HTTParty::Response#headers returns a HTTParty::Response::Headers object
-    which quacks like a Hash + Net::HTTPHeader. The #headers method continues
-    to be backwards-compatible with the old Hash return value but may become
-    deprecated in the future.
+== 0.5.2.2
+  * Update gem package to include the right version of httparty.rb
 
-* minor enhancements
-  * Update crack requirement to version 0.1.7
-    You may still get a warning because Crack's version constant is out of date
-  * Timeout option can be set for all requests using HTTParty.default_timeout (taazza)
-  * Closed #38 "headers hash should downcase keys so canonical header name can be used"
+== 0.5.2.1
+  * Update Pathname initialization to support earlier version of Ruby (1.8.4)
+  * Remove references to rubyforge
 
 == 0.5.2 2010-01-31
 * minor enhancements

data/Rakefile

@@ -7,14 +7,14 @@ begin
     gem.summary = %Q{Makes http fun! Also, makes consuming restful web services dead easy.}
     gem.description = %Q{Makes http fun! Also, makes consuming restful web services dead easy.}
     gem.email = "nunemaker@gmail.com"
-    gem.homepage = "http://github.com/jugend/httparty"
+    gem.homepage = "http://httparty.rubyforge.org"
     gem.authors = ["John Nunemaker", "Sandro Turriate"]
-    gem.add_dependency 'crack', '0.1.7'
+    gem.add_dependency 'crack', '0.1.6'
     gem.add_development_dependency "activesupport", "~>2.3"
-    gem.add_development_dependency "cucumber", "~>0.7"
+    gem.add_development_dependency "cucumber", "~>0.4"
     gem.add_development_dependency "fakeweb", "~>1.2"
     gem.add_development_dependency "mongrel", "~>1.1"
-    gem.add_development_dependency "rspec", "~>1.3"
+    gem.add_development_dependency "rspec", "1.2.9"
     gem.post_install_message = "When you HTTParty, you must party hard!"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.5.3.4
+0.5.2.3

data/features/steps/env.rb

@@ -4,14 +4,7 @@ require 'lib/httparty'
 require 'spec/expectations'
 
 Before do
-  def new_port
-    server = TCPServer.new('0.0.0.0', nil)
-    port = server.addr[1]
-  ensure
-    server.close
-  end
-
-  port = ENV["HTTPARTY_PORT"] || new_port
+  port = ENV["HTTPARTY_PORT"] || 31981
   @host_and_port = "0.0.0.0:#{port}"
   @server = Mongrel::HttpServer.new("0.0.0.0", port)
   @server.run

data/features/steps/httparty_steps.rb

@@ -17,11 +17,3 @@ When /I call HTTParty#get with '(.*)' and a basic_auth hash:/ do |url, auth_tabl
     :basic_auth => { :username => h["username"], :password => h["password"] }
   )
 end
-
-When /I call HTTParty#get with '(.*)' and a digest_auth hash:/ do |url, auth_table|
-  h = auth_table.hashes.first
-  @response_from_httparty = HTTParty.get(
-    "http://#{@host_and_port}#{url}",
-    :digest_auth => { :username => h["username"], :password => h["password"] }
-  )
-end

data/features/steps/mongrel_helper.rb

@@ -50,28 +50,6 @@ def add_basic_authentication_to(handler)
   handler.extend(m)
 end
 
-def add_digest_authentication_to(handler)
-  m = Module.new do
-    attr_writer :username, :password
-
-    def self.extended(base)
-      base.instance_eval { @custom_headers["WWW-Authenticate"] = 'Digest realm="testrealm@host.com",qop="auth,auth-int",nonce="nonce",opaque="opaque"' }
-      base.class_eval { alias_method_chain :process, :digest_authentication }
-    end
-
-    def process_with_digest_authentication(request, response)
-      if authorized?(request) then process_without_digest_authentication(request, response)
-      else reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
-      end
-    end
-
-    def authorized?(request)
-      request.params["HTTP_AUTHORIZATION"] =~ /Digest.*uri=/
-    end
-  end
-  handler.extend(m)
-end
-
 def new_mongrel_redirector(target_url, relative_path = false)
   target_url = "http://#{@host_and_port}#{target_url}" unless relative_path
   Mongrel::RedirectHandler.new(target_url)

data/features/steps/remote_service_steps.rb

@@ -13,8 +13,8 @@ Given /that service is accessed at the path '(.*)'/ do |path|
 end
 
 Given /^that service takes (\d+) seconds to generate a response$/ do |time|
-  @server_response_time = time.to_i
-  @handler.preprocessor = lambda { sleep time.to_i }
+  preprocessor = lambda { sleep time.to_i }
+  @handler.preprocessor = preprocessor
 end
 
 Given /the response from the service has a Content-Type of '(.*)'/ do |content_type|
@@ -33,10 +33,6 @@ Given /that service is protected by Basic Authentication/ do
   add_basic_authentication_to @handler
 end
 
-Given /that service is protected by Digest Authentication/ do
-  add_digest_authentication_to @handler
-end
-
 Given /that service requires the username '(.*)' with the password '(.*)'/ do |username, password|
   @handler.username = username
   @handler.password = password
@@ -54,8 +50,3 @@ end
 Given /I want to hit this in a browser/ do
   @server.acceptor.join
 end
-
-Then /I wait for the server to recover/ do
-  timeout = @request_options[:timeout] || 0
-  sleep @server_response_time - timeout
-end

data/features/supports_timeout_option.feature

@@ -10,4 +10,3 @@ Feature: Supports the timeout option
     When I set my HTTParty timeout option to 1
     And I call HTTParty#get with '/service.html'
     Then it should raise a Timeout::Error exception
-    And I wait for the server to recover

data/jugend-httparty.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{jugend-httparty}
-  s.version = "0.5.2.2"
+  s.version = "0.5.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker", "Sandro Turriate"]
-  s.date = %q{2010-06-10}
+  s.date = %q{2010-06-11}
   s.default_executable = %q{httparty}
   s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
   s.email = %q{nunemaker@gmail.com}

data/lib/httparty.rb

@@ -3,15 +3,17 @@ require 'net/http'
 require 'net/https'
 require 'crack'
 
-dir = Pathname.new(__FILE__).dirname.expand_path
+if Crack::VERSION != "0.1.6"
+  warn "warning: HTTParty depends on version 0.1.6 of crack, not #{Crack::VERSION}."
+end
+
+dir = Pathname(__FILE__).dirname.expand_path
 
 require dir + 'httparty/module_inheritable_attributes'
 require dir + 'httparty/cookie_hash'
-require dir + 'httparty/net_digest_auth'
 
 module HTTParty
   VERSION = "0.5.2".freeze
-  CRACK_DEPENDENCY = "0.1.7".freeze
 
   module AllowedFormatsDeprecation
     def const_missing(const)
@@ -71,16 +73,6 @@ module HTTParty
       default_options[:basic_auth] = {:username => u, :password => p}
     end
 
-    # Allows setting digest authentication username and password.
-    #
-    #   class Foo
-    #     include HTTParty
-    #     digest_auth 'username', 'password'
-    #   end
-    def digest_auth(u, p)
-      default_options[:digest_auth] = {:username => u, :password => p}
-    end
-
     # Allows setting default parameters to be appended to each request.
     # Great for api keys and such.
     #
@@ -94,18 +86,6 @@ module HTTParty
       default_options[:default_params].merge!(h)
     end
 
-    # Allows setting a default timeout for all HTTP calls
-    # Timeout is specified in seconds.
-    #
-    #   class Foo
-    #     include HTTParty
-    #     default_timeout 10
-    #   end
-    def default_timeout(t)
-      raise ArgumentError, 'Timeout must be an integer' unless t && t.is_a?(Integer)
-      default_options[:timeout] = t
-    end
-
     # Set an output stream for debugging, defaults to $stderr.
     # The output stream is passed on to Net::HTTP#set_debug_output.
     #
@@ -117,7 +97,7 @@ module HTTParty
       default_options[:debug_output] = stream
     end
 
-    # Allows setting HTTP headers to be used for each request.
+    # Allows setting a base uri to be used for each request.
     #
     #   class Foo
     #     include HTTParty
@@ -174,21 +154,6 @@ module HTTParty
       default_options[:no_follow] = value
     end
 
-    # Declare that you wish to maintain the chosen HTTP method across redirects.
-    # The default behavior is to follow redirects via the GET method.
-    # If you wish to maintain the original method, you can set this option to true.
-    #
-    # @example
-    #   class Foo
-    #     include HTTParty
-    #     base_uri 'http://google.com'
-    #     maintain_method_across_redirects true
-    #   end
-
-    def maintain_method_across_redirects(value = true)
-      default_options[:maintain_method_across_redirects] = value
-    end
-
     # Allows setting a PEM file to be used
     #
     #   class Foo
@@ -337,7 +302,3 @@ require dir + 'httparty/exceptions'
 require dir + 'httparty/parser'
 require dir + 'httparty/request'
 require dir + 'httparty/response'
-
-if Crack::VERSION != HTTParty::CRACK_DEPENDENCY
-  warn "warning: HTTParty depends on version #{HTTParty::CRACK_DEPENDENCY} of crack, not #{Crack::VERSION}."
-end

data/lib/httparty/request.rb

@@ -13,7 +13,7 @@ module HTTParty
 
     SupportedURISchemes  = [URI::HTTP, URI::HTTPS]
 
-    attr_accessor :http_method, :path, :options, :last_response, :redirect
+    attr_accessor :http_method, :path, :options, :last_response
 
     def initialize(http_method, path, o={})
       self.http_method = http_method
@@ -33,7 +33,7 @@ module HTTParty
       new_uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
 
       # avoid double query string on redirects [#12]
-      unless redirect
+      unless @redirect
         new_uri.query = query_string(new_uri)
       end
 
@@ -52,6 +52,7 @@ module HTTParty
       options[:parser]
     end
 
+
     def perform
       validate
       setup_raw_request
@@ -61,146 +62,133 @@ module HTTParty
 
     private
 
-    def http
-      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
-      http.use_ssl = ssl_implied?
+      def http
+        http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+        http.use_ssl = ssl_implied?
 
-      if options[:timeout] && options[:timeout].is_a?(Integer)
-        http.open_timeout = options[:timeout]
-        http.read_timeout = options[:timeout]
-      end
+        if options[:timeout] && options[:timeout].is_a?(Integer)
+          http.open_timeout = options[:timeout]
+          http.read_timeout = options[:timeout]
+        end
 
-      if options[:pem] && http.use_ssl?
-        http.cert = OpenSSL::X509::Certificate.new(options[:pem])
-        http.key = OpenSSL::PKey::RSA.new(options[:pem])
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      else
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-
-      if options[:debug_output]
-        http.set_debug_output(options[:debug_output])
-      end
+        if options[:pem] && http.use_ssl?
+          http.cert = OpenSSL::X509::Certificate.new(options[:pem])
+          http.key = OpenSSL::PKey::RSA.new(options[:pem])
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
 
-      http
-    end
+        if options[:debug_output]
+          http.set_debug_output(options[:debug_output])
+        end
 
-    def ssl_implied?
-      uri.port == 443 || uri.instance_of?(URI::HTTPS)
-    end
+        http
+      end
 
-    def body
-      options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
-    end
+      def ssl_implied?
+        uri.port == 443 || uri.instance_of?(URI::HTTPS)
+      end
 
-    def credentials
-      options[:basic_auth] || options[:digest_auth]
-    end
+      def body
+        options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+      end
 
-    def username
-      credentials[:username]
-    end
+      def username
+        options[:basic_auth][:username]
+      end
 
-    def password
-      credentials[:password]
-    end
+      def password
+        options[:basic_auth][:password]
+      end
 
-    def setup_raw_request
-      @raw_request = http_method.new(uri.request_uri)
-      @raw_request.body = body if body
-      @raw_request.initialize_http_header(options[:headers])
-      @raw_request.basic_auth(username, password) if options[:basic_auth]
-      setup_digest_auth if options[:digest_auth]
-    end
+      def setup_raw_request
+        @raw_request = http_method.new(uri.request_uri)
+        @raw_request.body = body if body
+        @raw_request.initialize_http_header(options[:headers])
+        @raw_request.basic_auth(username, password) if options[:basic_auth]
+      end
 
-    def setup_digest_auth
-      res = http.head(uri.request_uri, options[:headers])
-      if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
-        @raw_request.digest_auth(username, password, res)
+      def perform_actual_request
+        http.request(@raw_request)
       end
-    end
 
-    def perform_actual_request
-      http.request(@raw_request)
-    end
+      def get_response
+        self.last_response = perform_actual_request
+        options[:format] ||= format_from_mimetype(last_response['content-type'])
+      end
 
-    def get_response
-      self.last_response = perform_actual_request
-      options[:format] ||= format_from_mimetype(last_response['content-type'])
-    end
+      def query_string(uri)
+        query_string_parts = []
+        query_string_parts << uri.query unless uri.query.nil?
 
-    def query_string(uri)
-      query_string_parts = []
-      query_string_parts << uri.query unless uri.query.nil?
+        if options[:query].is_a?(Hash)
+          query_string_parts << options[:default_params].merge(options[:query]).to_params
+        else
+          query_string_parts << options[:default_params].to_params unless options[:default_params].empty?
+          query_string_parts << options[:query] unless options[:query].nil?
+        end
 
-      if options[:query].is_a?(Hash)
-        query_string_parts << options[:default_params].merge(options[:query]).to_params
-      else
-        query_string_parts << options[:default_params].to_params unless options[:default_params].empty?
-        query_string_parts << options[:query] unless options[:query].nil?
+        query_string_parts.size > 0 ? query_string_parts.join('&') : nil
       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
-      case last_response
-        when Net::HTTPMultipleChoice, # 300
-        Net::HTTPMovedPermanently, # 301
-        Net::HTTPFound, # 302
-        Net::HTTPSeeOther, # 303
-        Net::HTTPUseProxy, # 305
-        Net::HTTPTemporaryRedirect
+      # Raises exception Net::XXX (http error code) if an http error occured
+      def handle_response
+        case last_response
+        when Net::HTTPMultipleChoice,              # 300
+          Net::HTTPMovedPermanently,               # 301
+          Net::HTTPFound,                          # 302
+          Net::HTTPSeeOther,                       # 303
+          Net::HTTPUseProxy,                       # 305
+          Net::HTTPTemporaryRedirect
           if last_response.key?('location')
             options[:limit] -= 1
             self.path = last_response['location']
-            self.redirect = true
-            self.http_method = Net::HTTP::Get unless options[:maintain_method_across_redirects]
+            @redirect = true
+            self.http_method = Net::HTTP::Get
             capture_cookies(last_response)
             perform
           else
             last_response
           end
         else
-          Response.new(last_response, parse_response(last_response.body))
+          Response.new(parse_response(last_response.body), last_response.body, last_response.code, last_response.message, last_response.to_hash)
+        end
       end
-    end
 
-    def parse_response(body)
-      parser.call(body, format)
-    end
+      def parse_response(body)
+        parser.call(body, format)
+      end
 
-    def capture_cookies(response)
-      return unless response['Set-Cookie']
-      cookies_hash = HTTParty::CookieHash.new()
-      cookies_hash.add_cookies(options[:headers]['Cookie']) if options[:headers] && options[:headers]['Cookie']
-      cookies_hash.add_cookies(response['Set-Cookie'])
-      options[:headers] ||= {}
-      options[:headers]['Cookie'] = cookies_hash.to_cookie_string
-    end
+      def capture_cookies(response)
+        return unless response['Set-Cookie']
+        cookies_hash = HTTParty::CookieHash.new()
+        cookies_hash.add_cookies(options[:headers]['Cookie']) if options[:headers] && options[:headers]['Cookie']
+        cookies_hash.add_cookies(response['Set-Cookie'])
+        options[:headers] ||= {}
+        options[:headers]['Cookie'] = cookies_hash.to_cookie_string
+      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
-    # SupportedFormats hash
-    def format_from_mimetype(mimetype)
-      if mimetype && parser.respond_to?(:format_from_mimetype)
-        parser.format_from_mimetype(mimetype)
+      # 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
+      # SupportedFormats hash
+      def format_from_mimetype(mimetype)
+        if mimetype && parser.respond_to?(:format_from_mimetype)
+          parser.format_from_mimetype(mimetype)
+        end
       end
-    end
 
       def validate
         raise HTTParty::RedirectionTooDeep.new(last_response), 'HTTP redirects too deep' if options[:limit].to_i <= 0
         raise ArgumentError, 'only get, post, put, delete, head, and options 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, 'only one authentication method, :basic_auth or :digest_auth may be used at a time' if options[:basic_auth] && options[:digest_auth]
         raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
-        raise ArgumentError, ':digest_auth must be a hash' if options[:digest_auth] && !options[:digest_auth].is_a?(Hash)
         raise ArgumentError, ':query must be hash if using HTTP Post' if post? && !options[:query].nil? && !options[:query].is_a?(Hash)
       end
 
-    def post?
-      Net::HTTP::Post == http_method
-    end
+      def post?
+        Net::HTTP::Post == http_method
+      end
   end
 end
+

data/lib/httparty/response.rb

@@ -1,62 +1,18 @@
 module HTTParty
   class Response < HTTParty::BasicObject #:nodoc:
-    class Headers
-      include Net::HTTPHeader
-
-      def initialize(header)
-        @header = header
-      end
-
-      def ==(other)
-        @header == other
-      end
-
-      def inspect
-        @header.inspect
-      end
-
-      def method_missing(name, *args, &block)
-        if @header.respond_to?(name)
-          @header.send(name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to?(method)
-        super || @header.respond_to?(method)
-      end
-    end
-
-    attr_reader :response, :parsed_response, :body, :headers
-
-    def initialize(response, parsed_response)
-      @response = response
-      @body = response.body
-      @parsed_response = parsed_response
-      @headers = Headers.new(response.to_hash)
-    end
-
-    def class
-      Object.instance_method(:class).bind(self).call
-    end
-
-    def code
-      response.code.to_i
-    end
-
-    def inspect
-      %(<#{self.class} @response=#{response.inspect}>)
+    attr_accessor :body, :code, :message, :headers
+    attr_reader :delegate
+
+    def initialize(delegate, body, code, message, headers={})
+      @delegate = delegate
+      @body = body
+      @code = code.to_i
+      @message = message
+      @headers = headers
     end
 
     def method_missing(name, *args, &block)
-      if parsed_response.respond_to?(name)
-        parsed_response.send(name, *args, &block)
-      elsif response.respond_to?(name)
-        response.send(name, *args, &block)
-      else
-        super
-      end
+      @delegate.send(name, *args, &block)
     end
   end
 end

data/spec/httparty/request_spec.rb

@@ -30,17 +30,6 @@ describe HTTParty::Request do
       @request.send(:setup_raw_request)
       @request.instance_variable_get(:@raw_request)['authorization'].should_not be_nil
     end
-
-    it "should use digest auth when configured" do
-      FakeWeb.register_uri(:head, "http://api.foo.com/v1",
-        :www_authenticate => 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false')
-
-      @request.options[:digest_auth] = {:username => 'foobar', :password => 'secret'}
-      @request.send(:setup_raw_request)
-
-      raw_request = @request.instance_variable_get(:@raw_request)
-      raw_request.instance_variable_get(:@header)['Authorization'].should_not be_nil
-    end
   end
 
   describe "#uri" do
@@ -364,13 +353,6 @@ describe HTTParty::Request do
         @request.perform.should == {"hash" => {"foo" => "bar"}}
         @request.http_method.should == Net::HTTP::Get
       end
-
-      it 'should not make resulting request a get request if options[:maintain_method_across_redirects] is true' do
-        @request.options[:maintain_method_across_redirects] = true
-        @request.http_method = Net::HTTP::Delete
-        @request.perform.should == {"hash" => {"foo" => "bar"}}
-        @request.http_method.should == Net::HTTP::Delete
-      end
     end
 
     describe "infinitely" do
@@ -391,25 +373,5 @@ describe HTTParty::Request do
       }.should raise_error(ArgumentError)
     end
   end
-
-  describe "argument validation" do
-    it "should raise argument error if basic_auth and digest_auth are both present" do
-      lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :basic_auth => {}, :digest_auth => {}).perform
-      }.should raise_error(ArgumentError, "only one authentication method, :basic_auth or :digest_auth may be used at a time")
-    end
-
-    it "should raise argument error if basic_auth is not a hash" do
-      lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :basic_auth => ["foo", "bar"]).perform
-      }.should raise_error(ArgumentError, ":basic_auth must be a hash")
-    end
-
-    it "should raise argument error if digest_auth is not a hash" do
-      lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :digest_auth => ["foo", "bar"]).perform
-      }.should raise_error(ArgumentError, ":digest_auth must be a hash")
-    end
-  end
 end
 

data/spec/httparty/response_spec.rb

@@ -1,83 +1,62 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 describe HTTParty::Response do
-  before do
-    @last_modified = Date.new(2010, 1, 15).to_s
-    @content_length = '1024'
-    @response_object = {'foo' => 'bar'}
-    @response_object = Net::HTTPOK.new('1.1', 200, 'OK')
-    @response_object.stub(:body => "{foo:'bar'}")
-    @response_object['last-modified'] = @last_modified
-    @response_object['content-length'] = @content_length
-    @parsed_response = {"foo" => "bar"}
-    @response = HTTParty::Response.new(@response_object, @parsed_response)
-  end
-
   describe "initialization" do
-    it "should set the Net::HTTP Response" do
-      @response.response.should == @response_object
+    before do
+      @response_object = {'foo' => 'bar'}
+      @body = "{foo:'bar'}"
+      @code = '200'
+      @message = 'OK'
+      @response = HTTParty::Response.new(@response_object, @body, @code, @message)
     end
-
+    
+    it "should set delegate" do
+      @response.delegate.should == @response_object
+    end
+    
     it "should set body" do
-      @response.body.should == @response_object.body
+      @response.body.should == @body
     end
-
+    
     it "should set code" do
-      @response.code.should.to_s == @response_object.code
+      @response.code.should.to_s == @code
     end
 
     it "should set code as a Fixnum" do
       @response.code.should be_an_instance_of(Fixnum)
     end
+    
+    it "should set body" do
+      @response.body.should == @body
+    end
   end
-
-  it "returns response headers" do
-    response = HTTParty::Response.new(@response_object, @parsed_response)
-    response.headers.should == {'last-modified' => [@last_modified], 'content-length' => [@content_length]}
+  
+  it "should be able to set headers during initialization" do
+    response = HTTParty::Response.new({'foo' => 'bar'}, "{foo:'bar'}", 200, 'OK', {'foo' => 'bar'})
+    response.headers.should == {'foo' => 'bar'}
   end
-
+  
   it "should send missing methods to delegate" do
-    response = HTTParty::Response.new(@response_object, {'foo' => 'bar'})
+    response = HTTParty::Response.new({'foo' => 'bar'}, "{foo:'bar'}", 200, 'OK')
     response['foo'].should == 'bar'
   end
-
-  it "should be able to iterate if it is array" do
-    response = HTTParty::Response.new(@response_object, [{'foo' => 'bar'}, {'foo' => 'baz'}])
+  
+  it "should be able to iterate delegate if it is array" do
+    response = HTTParty::Response.new([{'foo' => 'bar'}, {'foo' => 'baz'}], "[{foo:'bar'}, {foo:'baz'}]", 200, 'OK')
     response.size.should == 2
-    expect {
+    lambda {
       response.each { |item| }
-    }.to_not raise_error
-  end
-
-  it "allows headers to be accessed by mixed-case names in hash notation" do
-    response = HTTParty::Response.new(@response_object, @parsed_response)
-    response.headers['Content-LENGTH'].should == @content_length
-  end
-
-  it "returns a comma-delimited value when multiple values exist" do
-    @response_object.add_field 'set-cookie', 'csrf_id=12345; path=/'
-    @response_object.add_field 'set-cookie', '_github_ses=A123CdE; path=/'
-    response = HTTParty::Response.new(@response_object, @parsed_response)
-    response.headers['set-cookie'].should == "csrf_id=12345; path=/, _github_ses=A123CdE; path=/"
+    }.should_not raise_error
   end
-
-  # Backwards-compatibility - previously, #headers returned a Hash
-  it "responds to hash methods" do
-    response = HTTParty::Response.new(@response_object, @parsed_response)
-    hash_methods = {}.methods - response.headers.methods
-    hash_methods.each do |method_name|
-      response.headers.respond_to?(method_name).should be_true
-    end
-  end
-
+  
   xit "should allow hashes to be accessed with dot notation" do
     response = HTTParty::Response.new({'foo' => 'bar'}, "{foo:'bar'}", 200, 'OK')
     response.foo.should == 'bar'
   end
-
+  
   xit "should allow nested hashes to be accessed with dot notation" do
     response = HTTParty::Response.new({'foo' => {'bar' => 'baz'}}, "{foo: {bar:'baz'}}", 200, 'OK')
     response.foo.should == {'bar' => 'baz'}
     response.foo.bar.should == 'baz'
   end
-end
+end

data/spec/httparty_spec.rb

@@ -203,17 +203,6 @@ describe HTTParty do
     end
   end
 
-  describe "default timeout" do
-    it "should default to nil" do
-      @klass.default_options[:timeout].should == nil
-    end
-
-    it "should support updating" do
-      @klass.default_timeout 10
-      @klass.default_options[:timeout].should == 10
-    end
-  end
-
   describe "debug_output" do
     it "stores the given stream as a default_option" do
       @klass.debug_output $stdout
@@ -233,13 +222,6 @@ describe HTTParty do
     end
   end
 
-  describe "digest http authentication" do
-    it "should work" do
-      @klass.digest_auth 'foobar', 'secret'
-      @klass.default_options[:digest_auth].should == {:username => 'foobar', :password => 'secret'}
-    end
-  end
-
   describe "parser" do
     let(:parser) do
       Proc.new{ |data, format| CustomParser.parse(data) }
@@ -261,7 +243,7 @@ describe HTTParty do
       @klass.format :json
       class MyParser < HTTParty::Parser
         SupportedFormats = {}
-      end unless defined?(MyParser)
+      end
       expect do
         @klass.parser MyParser
       end.to raise_error(HTTParty::UnsupportedFormat)
@@ -334,18 +316,6 @@ describe HTTParty do
     end
   end
 
-  describe "#maintain_method_across_redirects" do
-    it "sets maintain_method_across_redirects to true by default" do
-      @klass.maintain_method_across_redirects
-      @klass.default_options[:maintain_method_across_redirects].should be_true
-    end
-
-    it "sets the maintain_method_across_redirects option to false" do
-      @klass.maintain_method_across_redirects false
-      @klass.default_options[:maintain_method_across_redirects].should be_false
-    end
-  end
-
   describe "with explicit override of automatic redirect handling" do
     before do
       @request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', :format => :xml, :no_follow => true)

data/spec/spec_helper.rb

@@ -2,6 +2,8 @@ require File.join(File.dirname(__FILE__), '..', 'lib', 'httparty')
 require 'spec/autorun'
 require 'fakeweb'
 
+FakeWeb.allow_net_connect = false
+
 def file_fixture(filename)
   open(File.join(File.dirname(__FILE__), 'fixtures', "#{filename.to_s}")).read
 end
@@ -10,10 +12,4 @@ Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].e
 
 Spec::Runner.configure do |config|
   config.include HTTParty::StubResponse
-  config.before(:suite) do
-    FakeWeb.allow_net_connect = false
-  end
-  config.after(:suite) do
-    FakeWeb.allow_net_connect = true
-  end
 end

data/spec/support/stub_response.rb

@@ -14,7 +14,7 @@ module HTTParty
     end
 
     def stub_response(body, code = 200)
-      unless defined?(@http) && @http
+      unless @http
         @http = Net::HTTP.new('localhost', 80)
         @request.stub!(:http).and_return(@http)
         @request.stub!(:uri).and_return(URI.parse("http://foo.com/foobar"))

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 5
   - 2
-  - 2
-  version: 0.5.2.2
+  - 3
+  version: 0.5.2.3
 platform: ruby
 authors: 
 - John Nunemaker
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-10 00:00:00 +08:00
+date: 2010-06-11 00:00:00 +08:00
 default_executable: httparty
 dependencies: 
 - !ruby/object:Gem::Dependency