httparty 0.5.2 → 0.6.0

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

@@ -1,5 +1,3 @@
-require 'uri'
-
 module HTTParty
   class Request #:nodoc:
     SupportedHTTPMethods = [
@@ -13,7 +11,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 +31,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
 
@@ -45,14 +43,13 @@ module HTTParty
     end
 
     def format
-      options[:format]
+      options[:format] || (format_from_mimetype(last_response['content-type']) if last_response)
     end
 
     def parser
       options[:parser]
     end
 
-
     def perform
       validate
       setup_raw_request
@@ -62,133 +59,157 @@ 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
+    def http
+      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
+      http.use_ssl = ssl_implied?
 
-        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
-
-        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 username
+      credentials[:username]
+    end
+
+    def password
+      credentials[:password]
+    end
 
-      def get_response
-        self.last_response = perform_actual_request
-        options[:format] ||= format_from_mimetype(last_response['content-type'])
+    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
+    end
+
+    def query_string(uri)
+      query_string_parts = []
+      query_string_parts << uri.query unless uri.query.nil?
 
-        query_string_parts.size > 0 ? query_string_parts.join('&') : 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
-          if last_response.key?('location')
-            options[:limit] -= 1
-            self.path = last_response['location']
-            @redirect = true
-            self.http_method = Net::HTTP::Get
-            capture_cookies(last_response)
-            perform
-          else
-            last_response
-          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
+      handle_deflation
+      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]
+          capture_cookies(last_response)
+          perform
         else
-          Response.new(parse_response(last_response.body), last_response.body, last_response.code, last_response.message, last_response.to_hash)
+          last_response
         end
+      else
+        Response.new(last_response, parse_response(last_response.body))
       end
+    end
 
-      def parse_response(body)
-        parser.call(body, format)
+    # Inspired by Ruby 1.9
+    def handle_deflation
+      case last_response["content-encoding"]
+      when "gzip"
+        body_io = StringIO.new(last_response.body)
+        last_response.body.replace Zlib::GzipReader.new(body_io).read
+      when "deflate"
+        last_response.body.replace Zlib::Inflate.inflate(last_response.body)
       end
+    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 parse_response(body)
+      parser.call(body, format)
+    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
+    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
+    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,63 @@
 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
+      Response
+    end
+
+    def code
+      response.code.to_i
+    end
+
+    def inspect
+      inspect_id = "%x" % (object_id * 2)
+      %(#<#{self.class}:0x#{inspect_id} @parsed_response=#{parsed_response.inspect}, @response=#{response.inspect}, @headers=#{headers.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

@@ -19,9 +19,34 @@ describe HTTParty::Request do
   end
 
   describe "#format" do
-    it "should return the correct parsing format" do
-      @request.format.should == :xml
+    context "request yet to be made" do
+      it "returns format option" do
+        request = HTTParty::Request.new 'get', '/', :format => :xml
+        request.format.should == :xml
+      end
+
+      it "returns nil format" do
+        request = HTTParty::Request.new 'get', '/'
+        request.format.should be_nil
+      end
+    end
+
+    context "request has been made" do
+      it "returns format option" do
+        request = HTTParty::Request.new 'get', '/', :format => :xml
+        request.last_response = stub
+        request.format.should == :xml
+      end
+
+      it "returns the content-type from the last response when the option is not set" do
+        request = HTTParty::Request.new 'get', '/'
+        response = stub
+        response.should_receive(:[]).with('content-type').and_return('text/json')
+        request.last_response = response
+        request.format.should == :json
+      end
     end
+
   end
 
   context "options" do
@@ -30,6 +55,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 +389,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 +416,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