httparty 0.10.0 → 0.14.0

data/lib/httparty/request.rb

@@ -7,40 +7,55 @@ module HTTParty
       Net::HTTP::Put,
       Net::HTTP::Delete,
       Net::HTTP::Head,
-      Net::HTTP::Options
+      Net::HTTP::Options,
+      Net::HTTP::Move,
+      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|
-      Array(query).map do |key, value|
+    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
-      end.flatten.sort.join('&')
+      end.flatten.join('&')
     end
 
     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,
-        :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)
@@ -52,14 +67,21 @@ module HTTParty
     end
 
     def uri
-      new_uri = path.relative? ? URI.parse("#{base_uri}#{path}") : path
+      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
 
@@ -67,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
@@ -92,7 +120,7 @@ module HTTParty
           chunks = []
 
           http_response.read_body do |fragment|
-            chunks << fragment
+            chunks << fragment unless options[:stream_body]
             block.call(fragment)
           end
 
@@ -100,8 +128,13 @@ module HTTParty
         end
       end
 
-      handle_deflation
-      handle_response(chunked_body)
+      handle_deflation unless http_method == Net::HTTP::Head
+      handle_host_redirection if response_redirects?
+      handle_response(chunked_body, &block)
+    end
+
+    def raw_body
+      @raw_request.body
     end
 
     private
@@ -111,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
@@ -141,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
@@ -160,32 +194,115 @@ 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?
       end
 
+      query_string_parts.reject!(&:empty?) unless query_string_parts == [""]
       query_string_parts.size > 0 ? query_string_parts.join('&') : nil
     end
 
-    def handle_response(body)
+    def get_charset
+      content_type = last_response["content-type"]
+      if content_type.nil?
+        return nil
+      end
+
+      if content_type =~ /;\s*charset\s*=\s*([^=,;"\s]+)/i
+        return $1
+      end
+
+      if content_type =~ /;\s*charset\s*=\s*"((\\.|[^\\"])+)"/i
+        return $1.gsub(/\\(.)/, '\1')
+      end
+
+      nil
+    end
+
+    def encode_with_ruby_encoding(body, charset)
+      encoding = Encoding.find(charset)
+      body.force_encoding(encoding)
+    rescue
+      body
+    end
+
+    def assume_utf16_is_big_endian
+      options[:assume_utf16_is_big_endian]
+    end
+
+    def encode_utf_16(body)
+      if body.bytesize >= 2
+        if body.getbyte(0) == 0xFF && body.getbyte(1) == 0xFE
+          return body.force_encoding("UTF-16LE")
+        elsif body.getbyte(0) == 0xFE && body.getbyte(1) == 0xFF
+          return body.force_encoding("UTF-16BE")
+        end
+      end
+
+      if assume_utf16_is_big_endian
+        body.force_encoding("UTF-16BE")
+      else
+        body.force_encoding("UTF-16LE")
+      end
+    end
+
+    def _encode_body(body)
+      charset = get_charset
+
+      if charset.nil?
+        return body
+      end
+
+      if "utf-16".casecmp(charset) == 0
+        encode_utf_16(body)
+      else
+        encode_with_ruby_encoding(body, charset)
+      end
+    end
+
+    def encode_body(body)
+      if "".respond_to?(:encoding)
+        _encode_body(body)
+      else
+        body
+      end
+    end
+
+    def handle_response(body, &block)
       if response_redirects?
         options[:limit] -= 1
+        if options[:logger]
+          logger = HTTParty::Logger.build(options[:logger], options[:log_level], options[:log_format])
+          logger.format(self, last_response)
+        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
+        perform(&block)
       else
-        body = body || last_response.body
-        Response.new(self, last_response, lambda { parse_response(body) }, :body => body)
+        body ||= last_response.body
+        body = encode_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)
@@ -197,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
@@ -215,9 +347,9 @@ 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.add_cookies(response['Set-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
     end
@@ -234,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/headers.rb

@@ -23,8 +23,8 @@ module HTTParty
         end
       end
 
-      def respond_to?(method)
-        super || @header.respond_to?(method)
+      def respond_to?(method, include_all = false)
+        super || @header.respond_to?(method, include_all)
       end
     end
   end

data/lib/httparty/response.rb

@@ -1,17 +1,24 @@
 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         = response.body || options[:body]
+      @body         = options[:body] || response.body
       @parsed_block = parsed_block
       @headers      = Headers.new(response.to_hash)
+
+      if request.options[:logger]
+        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
@@ -22,27 +29,49 @@ 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
 
-    def respond_to?(name)
-      return true if [:request, :response, :parsed_response, :body, :headers].include?(name)
-      parsed_response.respond_to?(name) || response.respond_to?(name)
+    # Support old multiple_choice? method from pre 2.0.0 era.
+    if ::RUBY_VERSION >= "2.0.0" && ::RUBY_PLATFORM != "java"
+      alias_method :multiple_choice?, :multiple_choices?
+    end
+
+    def respond_to?(name, include_all = false)
+      return true if RESPOND_TO_METHODS.include?(name)
+      parsed_response.respond_to?(name, include_all) || response.respond_to?(name, include_all)
     end
 
     protected
@@ -56,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.10.0"
+  VERSION = "0.14.0"
 end