jugend-httparty 0.5.2.3 → 0.5.3.4

data/History

@@ -1,12 +1,30 @@
-== 0.5.2.3
-  * Repackage gem, old gem contains master branch files
+== 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.2
-  * Update gem package to include the right version of httparty.rb
+== 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.1
-  * Update Pathname initialization to support earlier version of Ruby (1.8.4)
-  * Remove references to rubyforge
+* 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 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://httparty.rubyforge.org"
+    gem.homepage = "http://github.com/jugend/httparty"
     gem.authors = ["John Nunemaker", "Sandro Turriate"]
-    gem.add_dependency 'crack', '0.1.6'
+    gem.add_dependency 'crack', '0.1.7'
     gem.add_development_dependency "activesupport", "~>2.3"
-    gem.add_development_dependency "cucumber", "~>0.4"
+    gem.add_development_dependency "cucumber", "~>0.7"
     gem.add_development_dependency "fakeweb", "~>1.2"
     gem.add_development_dependency "mongrel", "~>1.1"
-    gem.add_development_dependency "rspec", "1.2.9"
+    gem.add_development_dependency "rspec", "~>1.3"
     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.2.3
+0.5.3.4

data/features/digest_authentication.feature

@@ -0,0 +1,20 @@
+Feature:  Digest Authentication
+
+  As a developer
+  I want to be able to use a service that requires Digest Authentication
+  Because that is not an uncommon requirement
+
+  Scenario: Passing no credentials to a page requiring Digest Authentication
+    Given a restricted page at '/protected.html'
+    When I call HTTParty#get with '/protected.html'
+    Then it should return a response with a 401 response code
+
+  Scenario: Passing proper credentials to a page requiring Digest Authentication
+    Given a remote service that returns 'Digest Authenticated Page'
+    And that service is accessed at the path '/protected.html'
+    And that service is protected by Digest Authentication
+    And that service requires the username 'jcash' with the password 'maninblack'
+    When I call HTTParty#get with '/protected.html' and a digest_auth hash:
+       | username | password   |
+       | jcash    | maninblack |
+    Then the return value should match 'Digest Authenticated Page'

data/features/steps/env.rb

@@ -4,7 +4,14 @@ require 'lib/httparty'
 require 'spec/expectations'
 
 Before do
-  port = ENV["HTTPARTY_PORT"] || 31981
+  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
   @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,3 +17,11 @@ 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,6 +50,28 @@ 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|
-  preprocessor = lambda { sleep time.to_i }
-  @handler.preprocessor = preprocessor
+  @server_response_time = time.to_i
+  @handler.preprocessor = lambda { sleep time.to_i }
 end
 
 Given /the response from the service has a Content-Type of '(.*)'/ do |content_type|
@@ -33,6 +33,10 @@ 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
@@ -50,3 +54,8 @@ 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,3 +10,4 @@ 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.3"
+  s.version = "0.5.3.4"
 
   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-11}
+  s.date = %q{2010-05-26}
   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}
@@ -38,6 +38,7 @@ Gem::Specification.new do |s|
      "features/basic_authentication.feature",
      "features/command_line.feature",
      "features/deals_with_http_error_codes.feature",
+     "features/digest_authentication.feature",
      "features/handles_multiple_formats.feature",
      "features/steps/env.rb",
      "features/steps/httparty_response_steps.rb",
@@ -52,6 +53,7 @@ Gem::Specification.new do |s|
      "lib/httparty/core_extensions.rb",
      "lib/httparty/exceptions.rb",
      "lib/httparty/module_inheritable_attributes.rb",
+     "lib/httparty/net_digest_auth.rb",
      "lib/httparty/parser.rb",
      "lib/httparty/request.rb",
      "lib/httparty/response.rb",
@@ -72,7 +74,7 @@ Gem::Specification.new do |s|
      "website/css/common.css",
      "website/index.html"
   ]
-  s.homepage = %q{http://httparty.rubyforge.org}
+  s.homepage = %q{http://github.com/jugend/httparty}
   s.post_install_message = %q{When you HTTParty, you must party hard!}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
@@ -101,27 +103,27 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<crack>, ["= 0.1.6"])
+      s.add_runtime_dependency(%q<crack>, ["= 0.1.7"])
       s.add_development_dependency(%q<activesupport>, ["~> 2.3"])
-      s.add_development_dependency(%q<cucumber>, ["~> 0.4"])
+      s.add_development_dependency(%q<cucumber>, ["~> 0.7"])
       s.add_development_dependency(%q<fakeweb>, ["~> 1.2"])
       s.add_development_dependency(%q<mongrel>, ["~> 1.1"])
-      s.add_development_dependency(%q<rspec>, ["= 1.2.9"])
+      s.add_development_dependency(%q<rspec>, ["~> 1.3"])
     else
-      s.add_dependency(%q<crack>, ["= 0.1.6"])
+      s.add_dependency(%q<crack>, ["= 0.1.7"])
       s.add_dependency(%q<activesupport>, ["~> 2.3"])
-      s.add_dependency(%q<cucumber>, ["~> 0.4"])
+      s.add_dependency(%q<cucumber>, ["~> 0.7"])
       s.add_dependency(%q<fakeweb>, ["~> 1.2"])
       s.add_dependency(%q<mongrel>, ["~> 1.1"])
-      s.add_dependency(%q<rspec>, ["= 1.2.9"])
+      s.add_dependency(%q<rspec>, ["~> 1.3"])
     end
   else
-    s.add_dependency(%q<crack>, ["= 0.1.6"])
+    s.add_dependency(%q<crack>, ["= 0.1.7"])
     s.add_dependency(%q<activesupport>, ["~> 2.3"])
-    s.add_dependency(%q<cucumber>, ["~> 0.4"])
+    s.add_dependency(%q<cucumber>, ["~> 0.7"])
     s.add_dependency(%q<fakeweb>, ["~> 1.2"])
     s.add_dependency(%q<mongrel>, ["~> 1.1"])
-    s.add_dependency(%q<rspec>, ["= 1.2.9"])
+    s.add_dependency(%q<rspec>, ["~> 1.3"])
   end
 end
 

data/lib/httparty.rb

@@ -3,17 +3,15 @@ require 'net/http'
 require 'net/https'
 require 'crack'
 
-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
+dir = Pathname.new(__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)
@@ -73,6 +71,16 @@ 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.
     #
@@ -86,6 +94,18 @@ 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.
     #
@@ -97,7 +117,7 @@ module HTTParty
       default_options[:debug_output] = stream
     end
 
-    # Allows setting a base uri to be used for each request.
+    # Allows setting HTTP headers to be used for each request.
     #
     #   class Foo
     #     include HTTParty
@@ -154,6 +174,21 @@ 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
@@ -302,3 +337,7 @@ 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/net_digest_auth.rb

@@ -0,0 +1,35 @@
+require 'digest/md5'
+require 'net/http'
+
+module Net
+  module HTTPHeader
+    def digest_auth(user, password, response)
+      response['www-authenticate'] =~ /^(\w+) (.*)/
+
+      params = {}
+      $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+      params.merge!("cnonce" => Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535))))
+
+      a_1 = Digest::MD5.hexdigest("#{user}:#{params['realm']}:#{password}")
+      a_2 = Digest::MD5.hexdigest("#{@method}:#{@path}")
+
+      request_digest = Digest::MD5.hexdigest(
+        [a_1, params['nonce'], "0", params['cnonce'], params['qop'], a_2].join(":")
+      )
+
+      header = [
+        %Q(Digest username="#{user}"),
+        %Q(realm="#{params['realm']}"),
+        %Q(qop="#{params['qop']}"),
+        %Q(uri="#{@path}"),
+        %Q(nonce="#{params['nonce']}"),
+        %Q(nc="0"),
+        %Q(cnonce="#{params['cnonce']}"),
+        %Q(opaque="#{params['opaque']}"),
+        %Q(response="#{request_digest}")
+      ]
+
+      @header['Authorization'] = header
+    end
+  end
+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
+    attr_accessor :http_method, :path, :options, :last_response, :redirect
 
     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,7 +52,6 @@ module HTTParty
       options[:parser]
     end
 
-
     def perform
       validate
       setup_raw_request
@@ -62,133 +61,146 @@ module HTTParty
 
     private
 
-      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[: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
+    def http
+      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+      http.use_ssl = ssl_implied?
 
-        http
+      if options[:timeout] && options[:timeout].is_a?(Integer)
+        http.open_timeout = options[:timeout]
+        http.read_timeout = options[:timeout]
       end
 
-      def ssl_implied?
-        uri.port == 443 || uri.instance_of?(URI::HTTPS)
+      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
 
-      def body
-        options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+      if options[:debug_output]
+        http.set_debug_output(options[:debug_output])
       end
 
-      def username
-        options[:basic_auth][:username]
-      end
+      http
+    end
 
-      def password
-        options[:basic_auth][:password]
-      end
+    def ssl_implied?
+      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    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 body
+      options[:body].is_a?(Hash) ? options[:body].to_params : options[:body]
+    end
 
-      def perform_actual_request
-        http.request(@raw_request)
-      end
+    def credentials
+      options[:basic_auth] || options[:digest_auth]
+    end
 
-      def get_response
-        self.last_response = perform_actual_request
-        options[:format] ||= format_from_mimetype(last_response['content-type'])
+    def username
+      credentials[:username]
+    end
+
+    def password
+      credentials[: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_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)
       end
+    end
 
-      def query_string(uri)
-        query_string_parts = []
-        query_string_parts << uri.query unless uri.query.nil?
+    def perform_actual_request
+      http.request(@raw_request)
+    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?
-        end
+    def get_response
+      self.last_response = perform_actual_request
+      options[:format] ||= format_from_mimetype(last_response['content-type'])
+    end
 
-        query_string_parts.size > 0 ? query_string_parts.join('&') : 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
 
-      # 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
+      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
           if last_response.key?('location')
             options[:limit] -= 1
             self.path = last_response['location']
-            @redirect = true
-            self.http_method = Net::HTTP::Get
+            self.redirect = true
+            self.http_method = Net::HTTP::Get unless options[:maintain_method_across_redirects]
             capture_cookies(last_response)
             perform
           else
             last_response
           end
         else
-          Response.new(parse_response(last_response.body), last_response.body, last_response.code, last_response.message, last_response.to_hash)
-        end
+          Response.new(last_response, parse_response(last_response.body))
       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)
-        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)
       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,18 +1,62 @@
 module HTTParty
   class Response < HTTParty::BasicObject #:nodoc:
-    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
+    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}>)
     end
 
     def method_missing(name, *args, &block)
-      @delegate.send(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
     end
   end
 end

data/spec/httparty/request_spec.rb

@@ -30,6 +30,17 @@ 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
@@ -353,6 +364,13 @@ 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
@@ -373,5 +391,25 @@ 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,62 +1,83 @@
 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
-    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
+    it "should set the Net::HTTP Response" do
+      @response.response.should == @response_object
     end
-    
+
     it "should set body" do
-      @response.body.should == @body
+      @response.body.should == @response_object.body
     end
-    
+
     it "should set code" do
-      @response.code.should.to_s == @code
+      @response.code.should.to_s == @response_object.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 "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'}
+
+  it "returns response headers" do
+    response = HTTParty::Response.new(@response_object, @parsed_response)
+    response.headers.should == {'last-modified' => [@last_modified], 'content-length' => [@content_length]}
   end
-  
+
   it "should send missing methods to delegate" do
-    response = HTTParty::Response.new({'foo' => 'bar'}, "{foo:'bar'}", 200, 'OK')
+    response = HTTParty::Response.new(@response_object, {'foo' => 'bar'})
     response['foo'].should == 'bar'
   end
-  
-  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')
+
+  it "should be able to iterate if it is array" do
+    response = HTTParty::Response.new(@response_object, [{'foo' => 'bar'}, {'foo' => 'baz'}])
     response.size.should == 2
-    lambda {
+    expect {
       response.each { |item| }
-    }.should_not raise_error
+    }.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=/"
   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,6 +203,17 @@ 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
@@ -222,6 +233,13 @@ 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) }
@@ -243,7 +261,7 @@ describe HTTParty do
       @klass.format :json
       class MyParser < HTTParty::Parser
         SupportedFormats = {}
-      end
+      end unless defined?(MyParser)
       expect do
         @klass.parser MyParser
       end.to raise_error(HTTParty::UnsupportedFormat)
@@ -316,6 +334,18 @@ 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,8 +2,6 @@ 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
@@ -12,4 +10,10 @@ 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 @http
+      unless defined?(@http) && @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

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 5
-  - 2
   - 3
-  version: 0.5.2.3
+  - 4
+  version: 0.5.3.4
 platform: ruby
 authors: 
 - John Nunemaker
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-11 00:00:00 +08:00
+date: 2010-05-26 00:00:00 +08:00
 default_executable: httparty
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,8 +29,8 @@ dependencies:
         segments: 
         - 0
         - 1
-        - 6
-        version: 0.1.6
+        - 7
+        version: 0.1.7
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -55,8 +55,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 4
-        version: "0.4"
+        - 7
+        version: "0.7"
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -90,13 +90,12 @@ dependencies:
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 1
-        - 2
-        - 9
-        version: 1.2.9
+        - 3
+        version: "1.3"
   type: :development
   version_requirements: *id006
 description: Makes http fun! Also, makes consuming restful web services dead easy.
@@ -128,6 +127,7 @@ files:
 - features/basic_authentication.feature
 - features/command_line.feature
 - features/deals_with_http_error_codes.feature
+- features/digest_authentication.feature
 - features/handles_multiple_formats.feature
 - features/steps/env.rb
 - features/steps/httparty_response_steps.rb
@@ -142,6 +142,7 @@ files:
 - lib/httparty/core_extensions.rb
 - lib/httparty/exceptions.rb
 - lib/httparty/module_inheritable_attributes.rb
+- lib/httparty/net_digest_auth.rb
 - lib/httparty/parser.rb
 - lib/httparty/request.rb
 - lib/httparty/response.rb
@@ -162,7 +163,7 @@ files:
 - website/css/common.css
 - website/index.html
 has_rdoc: true
-homepage: http://httparty.rubyforge.org
+homepage: http://github.com/jugend/httparty
 licenses: []
 
 post_install_message: When you HTTParty, you must party hard!