httparty 0.13.0 → 0.14.0

data/lib/httparty/module_inheritable_attributes.rb

@@ -10,7 +10,7 @@ module HTTParty
 
       duplicate.each_pair do |key, value|
         duplicate[key] = if value.is_a?(Hash)
-          hash_deep_dup(value)
+                           hash_deep_dup(value)
         elsif value.is_a?(Proc)
           duplicate[key] = value.dup
         else

data/lib/httparty/net_digest_auth.rb

@@ -4,10 +4,22 @@ require 'net/http'
 module Net
   module HTTPHeader
     def digest_auth(username, password, response)
-      @header['Authorization'] = DigestAuthenticator.new(username, password,
-          @method, @path, response).authorization_header
+      authenticator = DigestAuthenticator.new(
+        username,
+        password,
+        @method,
+        @path,
+        response
+      )
+
+      @header['Authorization'] = authenticator.authorization_header
+      @header['cookie'] = append_cookies(authenticator) if response['Set-Cookie']
     end
 
+    def append_cookies(authenticator)
+      cookies = @header['cookie'] ? @header['cookie'] : []
+      cookies.concat(authenticator.cookie_header)
+    end
 
     class DigestAuthenticator
       def initialize(username, password, method, path, response_header)
@@ -16,50 +28,76 @@ module Net
         @method   = method
         @path     = path
         @response = parse(response_header)
+        @cookies  = parse_cookies(response_header)
       end
 
       def authorization_header
         @cnonce = md5(random)
         header = [
-          %Q(Digest username="#{@username}"),
-          %Q(realm="#{@response['realm']}"),
-          %Q(nonce="#{@response['nonce']}"),
-          %Q(uri="#{@path}"),
-          %Q(response="#{request_digest}"),
+          %(Digest username="#{@username}"),
+          %(realm="#{@response['realm']}"),
+          %(nonce="#{@response['nonce']}"),
+          %(uri="#{@path}"),
+          %(response="#{request_digest}")
         ]
 
+        header << %(algorithm="#{@response['algorithm']}") if algorithm_present?
+
         if qop_present?
           fields = [
-            %Q(cnonce="#{@cnonce}"),
-            %Q(qop="#{@response['qop']}"),
-            %Q(nc=00000001)
+            %(cnonce="#{@cnonce}"),
+            %(qop="#{@response['qop']}"),
+            "nc=00000001"
           ]
           fields.each { |field| header << field }
         end
 
-        header << %Q(opaque="#{@response['opaque']}") if opaque_present?
+        header << %(opaque="#{@response['opaque']}") if opaque_present?
         header
       end
 
-    private
+      def cookie_header
+        @cookies
+      end
+
+      private
 
       def parse(response_header)
-        response_header['www-authenticate'] =~ /Digest (.*)/
+        header = response_header['www-authenticate']
+                 .gsub(/qop=(auth(?:-int)?)/, 'qop="\\1"')
+
+        header =~ /Digest (.*)/
         params = {}
-        $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        if $1
+          non_quoted = $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+          non_quoted.gsub(/(\w+)=([^,]*)/) { params[$1] = $2 }
+        end
         params
       end
 
+      def parse_cookies(response_header)
+        return [] unless response_header['Set-Cookie']
+
+        cookies = response_header['Set-Cookie'].split('; ')
+
+        cookies.reduce([]) do |ret, cookie|
+          ret << cookie
+          ret
+        end
+
+        cookies
+      end
+
       def opaque_present?
-        @response.has_key?('opaque') and not @response['opaque'].empty?
+        @response.key?('opaque') && !@response['opaque'].empty?
       end
 
       def qop_present?
-        @response.has_key?('qop') and not @response['qop'].empty?
+        @response.key?('qop') && !@response['qop'].empty?
       end
 
       def random
-        "%x" % (Time.now.to_i + rand(65535))
+        format "%x", (Time.now.to_i + rand(65535))
       end
 
       def request_digest
@@ -72,8 +110,21 @@ module Net
         Digest::MD5.hexdigest(str)
       end
 
+      def algorithm_present?
+        @response.key?('algorithm') && !@response['algorithm'].empty?
+      end
+      
+      def use_md5_sess?
+        algorithm_present? && @response['algorithm'] == 'MD5-sess'
+      end
+      
       def a1
-        [@username, @response['realm'], @password].join(":")
+        a1_user_realm_pwd =  [@username, @response['realm'], @password].join(':')
+        if use_md5_sess?
+          [ md5(a1_user_realm_pwd), @response['nonce'], @cnonce ].join(':')
+        else
+          a1_user_realm_pwd
+        end
       end
 
       def a2

data/lib/httparty/parser.rb

@@ -98,7 +98,9 @@ module HTTParty
     # @return [Object] the parsed body
     # @return [nil] when the response body is nil, an empty string, spaces only or "null"
     def parse
-      return nil if body.nil? || body.strip.empty? || body == "null"
+      return nil if body.nil?
+      return nil if body == "null"
+      return nil if body.valid_encoding? && body.strip.empty?
       if supports_format?
         parse_supported_format
       else
@@ -113,7 +115,7 @@ module HTTParty
     end
 
     def json
-      JSON.load(body, nil)
+      JSON.parse(body, :quirks_mode => true, :allow_nan => true)
     end
 
     def csv

data/lib/httparty/request.rb

@@ -9,17 +9,18 @@ module HTTParty
       Net::HTTP::Head,
       Net::HTTP::Options,
       Net::HTTP::Move,
-      Net::HTTP::Copy
+      Net::HTTP::Copy,
+      Net::HTTP::Mkcol,
     ]
 
-    SupportedURISchemes  = [URI::HTTP, URI::HTTPS, URI::Generic]
+    SupportedURISchemes  = ['http', 'https', 'webcal', nil]
 
-    NON_RAILS_QUERY_STRING_NORMALIZER = Proc.new do |query|
+    NON_RAILS_QUERY_STRING_NORMALIZER = proc do |query|
       Array(query).sort_by { |a| a[0].to_s }.map do |key, value|
         if value.nil?
           key.to_s
-        elsif value.is_a?(Array)
-          value.map {|v| "#{key}=#{URI.encode(v.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}"}
+        elsif value.respond_to?(:to_ary)
+          value.to_ary.map {|v| "#{key}=#{ERB::Util.url_encode(v.to_s)}"}
         else
           HashConversions.to_params(key => value)
         end
@@ -29,21 +30,32 @@ module HTTParty
     attr_accessor :http_method, :options, :last_response, :redirect, :last_uri
     attr_reader :path
 
-    def initialize(http_method, path, o={})
+    def initialize(http_method, path, o = {})
       self.http_method = http_method
-      self.path = path
       self.options = {
-        :limit => o.delete(:no_follow) ? 1 : 5,
-        :assume_utf16_is_big_endian => true,
-        :default_params => {},
-        :follow_redirects => true,
-        :parser => Parser,
-        :connection_adapter => ConnectionAdapter
+        limit: o.delete(:no_follow) ? 1 : 5,
+        assume_utf16_is_big_endian: true,
+        default_params: {},
+        follow_redirects: true,
+        parser: Parser,
+        uri_adapter: URI,
+        connection_adapter: ConnectionAdapter
       }.merge(o)
+      self.path = path
+      set_basic_auth_from_uri
     end
 
     def path=(uri)
-      @path = URI.parse(uri)
+      uri_adapter = options[:uri_adapter]
+
+      @path = if uri.is_a?(uri_adapter)
+        uri
+      elsif String.try_convert(uri)
+        uri_adapter.parse uri
+      else
+        raise ArgumentError,
+          "bad argument (expected #{uri_adapter} object or URI string)"
+      end
     end
 
     def request_uri(uri)
@@ -55,14 +67,21 @@ module HTTParty
     end
 
     def uri
-      new_uri = path.relative? ? URI.parse("#{base_uri}#{path}") : path.clone
+      if redirect && path.relative? && path.path[0] != "/"
+        last_uri_host = @last_uri.path.gsub(/[^\/]+$/, "")
+
+        path.path = "/#{path.path}" if last_uri_host[-1] != "/"
+        path.path = last_uri_host + path.path
+      end
+
+      new_uri = path.relative? ? options[:uri_adapter].parse("#{base_uri}#{path}") : path.clone
 
       # avoid double query string on redirects [#12]
       unless redirect
         new_uri.query = query_string(new_uri)
       end
 
-      unless SupportedURISchemes.include? new_uri.class
+      unless SupportedURISchemes.include? new_uri.scheme
         raise UnsupportedURIScheme, "'#{new_uri}' Must be HTTP, HTTPS or Generic"
       end
 
@@ -70,7 +89,13 @@ module HTTParty
     end
 
     def base_uri
-      redirect ? "#{@last_uri.scheme}://#{@last_uri.host}" : options[:base_uri]
+      if redirect
+        base_uri = "#{@last_uri.scheme}://#{@last_uri.host}"
+        base_uri += ":#{@last_uri.port}" if @last_uri.port != 80
+        base_uri
+      else
+        options[:base_uri] && HTTParty.normalize_base_uri(options[:base_uri])
+      end
     end
 
     def format
@@ -95,7 +120,7 @@ module HTTParty
           chunks = []
 
           http_response.read_body do |fragment|
-            chunks << fragment
+            chunks << fragment unless options[:stream_body]
             block.call(fragment)
           end
 
@@ -104,6 +129,7 @@ module HTTParty
       end
 
       handle_deflation unless http_method == Net::HTTP::Head
+      handle_host_redirection if response_redirects?
       handle_response(chunked_body, &block)
     end
 
@@ -118,11 +144,11 @@ module HTTParty
     end
 
     def body
-      options[:body].is_a?(Hash) ? normalize_query(options[:body]) : options[:body]
+      options[:body].respond_to?(:to_hash) ? normalize_query(options[:body]) : options[:body]
     end
 
     def credentials
-      options[:basic_auth] || options[:digest_auth]
+      (options[:basic_auth] || options[:digest_auth]).to_hash
     end
 
     def username
@@ -148,17 +174,18 @@ module HTTParty
     def setup_raw_request
       @raw_request = http_method.new(request_uri(uri))
       @raw_request.body = body if body
-      @raw_request.initialize_http_header(options[:headers])
-      @raw_request.basic_auth(username, password) if options[:basic_auth]
+      @raw_request.body_stream = options[:body_stream] if options[:body_stream]
+      @raw_request.initialize_http_header(options[:headers].to_hash) if options[:headers].respond_to?(:to_hash)
+      @raw_request.basic_auth(username, password) if options[:basic_auth] && send_authorization_header?
       setup_digest_auth if options[:digest_auth]
     end
 
     def setup_digest_auth
       auth_request = http_method.new(uri.request_uri)
-      auth_request.initialize_http_header(options[:headers])
+      auth_request.initialize_http_header(options[:headers].to_hash) if options[:headers].respond_to?(:to_hash)
       res = http.request(auth_request)
 
-      if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
+      if !res['www-authenticate'].nil? && res['www-authenticate'].length > 0
         @raw_request.digest_auth(username, password, res)
       end
     end
@@ -167,8 +194,8 @@ module HTTParty
       query_string_parts = []
       query_string_parts << uri.query unless uri.query.nil?
 
-      if options[:query].is_a?(Hash)
-        query_string_parts << normalize_query(options[:default_params].merge(options[:query]))
+      if options[:query].respond_to?(:to_hash)
+        query_string_parts << normalize_query(options[:default_params].merge(options[:query].to_hash))
       else
         query_string_parts << normalize_query(options[:default_params]) unless options[:default_params].empty?
         query_string_parts << options[:query] unless options[:query].nil?
@@ -196,12 +223,10 @@ module HTTParty
     end
 
     def encode_with_ruby_encoding(body, charset)
-      begin
-        encoding = Encoding.find(charset)
-        body.force_encoding(encoding)
-      rescue
-        body
-      end
+      encoding = Encoding.find(charset)
+      body.force_encoding(encoding)
+    rescue
+      body
     end
 
     def assume_utf16_is_big_endian
@@ -222,7 +247,6 @@ module HTTParty
       else
         body.force_encoding("UTF-16LE")
       end
-
     end
 
     def _encode_body(body)
@@ -256,18 +280,29 @@ module HTTParty
         end
         self.path = last_response['location']
         self.redirect = true
-        self.http_method = Net::HTTP::Get unless options[:maintain_method_across_redirects]
+        if last_response.class == Net::HTTPSeeOther
+          unless options[:maintain_method_across_redirects] && options[:resend_on_redirect]
+            self.http_method = Net::HTTP::Get
+          end
+        elsif last_response.code != '307' && last_response.code != '308'
+          unless options[:maintain_method_across_redirects]
+            self.http_method = Net::HTTP::Get
+          end
+        end
         capture_cookies(last_response)
         perform(&block)
       else
-        body = body || last_response.body
+        body ||= last_response.body
         body = encode_body(body)
-        Response.new(self, last_response, lambda { parse_response(body) }, :body => body)
+        Response.new(self, last_response, lambda { parse_response(body) }, body: body)
       end
     end
 
     # Inspired by Ruby 1.9
     def handle_deflation
+      return if response_redirects?
+      return if last_response.body.nil?
+
       case last_response["content-encoding"]
       when "gzip", "x-gzip"
         body_io = StringIO.new(last_response.body)
@@ -279,14 +314,29 @@ module HTTParty
       end
     end
 
+    def handle_host_redirection
+      check_duplicate_location_header
+      redirect_path = options[:uri_adapter].parse last_response['location']
+      return if redirect_path.relative? || path.host == redirect_path.host
+      @changed_hosts = true
+    end
+
+    def check_duplicate_location_header
+      location = last_response.get_fields('location')
+      if location.is_a?(Array) && location.count > 1
+        raise DuplicateLocationHeader.new(last_response)
+      end
+    end
+
+    def send_authorization_header?
+      !defined?(@changed_hosts)
+    end
+
     def response_redirects?
       case last_response
-      when Net::HTTPMultipleChoice, # 300
-           Net::HTTPMovedPermanently, # 301
-           Net::HTTPFound, # 302
-           Net::HTTPSeeOther, # 303
-           Net::HTTPUseProxy, # 305
-           Net::HTTPTemporaryRedirect
+      when Net::HTTPNotModified # 304
+        false
+      when Net::HTTPRedirection
         options[:follow_redirects] && last_response.key?('location')
       end
     end
@@ -297,8 +347,8 @@ module HTTParty
 
     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 = HTTParty::CookieHash.new
+      cookies_hash.add_cookies(options[:headers].to_hash['Cookie']) if options[:headers] && options[:headers].to_hash['Cookie']
       response.get_fields('Set-Cookie').each { |cookie| cookies_hash.add_cookies(cookie) }
       options[:headers] ||= {}
       options[:headers]['Cookie'] = cookies_hash.to_cookie_string
@@ -316,15 +366,22 @@ module HTTParty
     def validate
       raise HTTParty::RedirectionTooDeep.new(last_response), 'HTTP redirects too deep' if options[:limit].to_i <= 0
       raise ArgumentError, 'only get, post, patch, 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, ':headers must be a hash' if options[:headers] && !options[:headers].respond_to?(:to_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)
+      raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].respond_to?(:to_hash)
+      raise ArgumentError, ':digest_auth must be a hash' if options[:digest_auth] && !options[:digest_auth].respond_to?(:to_hash)
+      raise ArgumentError, ':query must be hash if using HTTP Post' if post? && !options[:query].nil? && !options[:query].respond_to?(:to_hash)
     end
 
     def post?
       Net::HTTP::Post == http_method
     end
+
+    def set_basic_auth_from_uri
+      if path.userinfo
+        username, password = path.userinfo.split(':')
+        options[:basic_auth] = {username: username, password: password}
+      end
+    end
   end
 end

data/lib/httparty/response.rb

@@ -1,12 +1,12 @@
 module HTTParty
-  class Response < HTTParty::BasicObject #:nodoc:
+  class Response < BasicObject
     def self.underscore(string)
-      string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+      string.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
     end
 
     attr_reader :request, :response, :body, :headers
 
-    def initialize(request, response, parsed_block, options={})
+    def initialize(request, response, parsed_block, options = {})
       @request      = request
       @response     = response
       @body         = options[:body] || response.body
@@ -17,6 +17,8 @@ module HTTParty
         logger = ::HTTParty::Logger.build(request.options[:logger], request.options[:log_level], request.options[:log_format])
         logger.format(request, self)
       end
+
+      throw_exception
     end
 
     def parsed_response
@@ -27,20 +29,37 @@ module HTTParty
       Response
     end
 
+    def is_a?(klass)
+      self.class == klass || self.class < klass
+    end
+
+    alias_method :kind_of?, :is_a?
+
     def code
       response.code.to_i
     end
 
+    def tap
+      yield self
+      self
+    end
+
     def inspect
-      inspect_id = "%x" % (object_id * 2)
+      inspect_id = ::Kernel::format "%x", (object_id * 2)
       %(#<#{self.class}:0x#{inspect_id} parsed_response=#{parsed_response.inspect}, @response=#{response.inspect}, @headers=#{headers.inspect}>)
     end
 
+    RESPOND_TO_METHODS = [:request, :response, :parsed_response, :body, :headers]
+
     CODES_TO_OBJ = ::Net::HTTPResponse::CODE_CLASS_TO_OBJ.merge ::Net::HTTPResponse::CODE_TO_OBJ
 
     CODES_TO_OBJ.each do |response_code, klass|
       name = klass.name.sub("Net::HTTP", '')
-      define_method("#{underscore(name)}?") do
+      name = "#{underscore(name)}?".to_sym
+
+      RESPOND_TO_METHODS << name
+
+      define_method(name) do
         klass === response
       end
     end
@@ -51,7 +70,7 @@ module HTTParty
     end
 
     def respond_to?(name, include_all = false)
-      return true if [:request, :response, :parsed_response, :body, :headers].include?(name)
+      return true if RESPOND_TO_METHODS.include?(name)
       parsed_response.respond_to?(name, include_all) || response.respond_to?(name, include_all)
     end
 
@@ -66,6 +85,12 @@ module HTTParty
         super
       end
     end
+
+    def throw_exception
+      if @request.options[:raise_on] && @request.options[:raise_on].include?(code)
+        ::Kernel.raise ::HTTParty::ResponseError.new(@response), "Code #{code} - #{body}"
+      end
+    end
   end
 end
 

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end