httparty 0.15.0 → 0.21.0

data/lib/httparty/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erb'
 
 module HTTParty
@@ -13,6 +15,8 @@ module HTTParty
       Net::HTTP::Move,
       Net::HTTP::Copy,
       Net::HTTP::Mkcol,
+      Net::HTTP::Lock,
+      Net::HTTP::Unlock,
     ]
 
     SupportedURISchemes  = ['http', 'https', 'webcal', nil]
@@ -42,6 +46,15 @@ module HTTParty
       end.flatten.join('&')
     end
 
+    def self._load(data)
+      http_method, path, options, last_response, last_uri, raw_request = Marshal.load(data)
+      instance = new(http_method, path, options)
+      instance.last_response = last_response
+      instance.last_uri = last_uri
+      instance.instance_variable_set("@raw_request", raw_request)
+      instance
+    end
+
     attr_accessor :http_method, :options, :last_response, :redirect, :last_uri
     attr_reader :path
 
@@ -60,7 +73,7 @@ module HTTParty
         connection_adapter: ConnectionAdapter
       }.merge(o)
       self.path = path
-      set_basic_auth_from_uri      
+      set_basic_auth_from_uri
     end
 
     def path=(uri)
@@ -69,7 +82,7 @@ module HTTParty
       @path = if uri.is_a?(uri_adapter)
         uri
       elsif String.try_convert(uri)
-        uri_adapter.parse uri
+        uri_adapter.parse(uri).normalize
       else
         raise ArgumentError,
           "bad argument (expected #{uri_adapter} object or URI string)"
@@ -85,17 +98,17 @@ module HTTParty
     end
 
     def uri
-      if redirect && path.relative? && path.path[0] != "/"
-        last_uri_host = @last_uri.path.gsub(/[^\/]+$/, "")
+      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
+        path.path = "/#{path.path}" if last_uri_host[-1] != '/'
+        path.path = "#{last_uri_host}#{path.path}"
       end
 
       if path.relative? && path.host
-        new_uri = options[:uri_adapter].parse("#{@last_uri.scheme}:#{path}")
+        new_uri = options[:uri_adapter].parse("#{@last_uri.scheme}:#{path}").normalize
       elsif path.relative?
-        new_uri = options[:uri_adapter].parse("#{base_uri}#{path}")
+        new_uri = options[:uri_adapter].parse("#{base_uri}#{path}").normalize
       else
         new_uri = path.clone
       end
@@ -115,7 +128,7 @@ module HTTParty
     def base_uri
       if redirect
         base_uri = "#{@last_uri.scheme}://#{@last_uri.host}"
-        base_uri += ":#{@last_uri.port}" if @last_uri.port != 80
+        base_uri = "#{base_uri}:#{@last_uri.port}" if @last_uri.port != 80
         base_uri
       else
         options[:base_uri] && HTTParty.normalize_base_uri(options[:base_uri])
@@ -138,31 +151,32 @@ module HTTParty
       validate
       setup_raw_request
       chunked_body = nil
+      current_http = http
 
-      self.last_response = http.request(@raw_request) do |http_response|
+      self.last_response = current_http.request(@raw_request) do |http_response|
         if block
           chunks = []
 
           http_response.read_body do |fragment|
-            chunks << fragment unless options[:stream_body]
-            block.call(fragment)
+            encoded_fragment = encode_text(fragment, http_response['content-type'])
+            chunks << encoded_fragment if !options[:stream_body]
+            block.call ResponseFragment.new(encoded_fragment, http_response, current_http)
           end
 
           chunked_body = chunks.join
         end
       end
-      
-      
+
       handle_host_redirection if response_redirects?
       result = handle_unauthorized
       result ||= handle_response(chunked_body, &block)
-      result      
+      result
     end
 
     def handle_unauthorized(&block)
       return unless digest_auth? && response_unauthorized? && response_has_digest_auth_challenge?
       return if @credentials_sent
-      @credentials_sent = true      
+      @credentials_sent = true
       perform(&block)
     end
 
@@ -170,16 +184,19 @@ module HTTParty
       @raw_request.body
     end
 
+    def _dump(_level)
+      opts = options.dup
+      opts.delete(:logger)
+      opts.delete(:parser) if opts[:parser] && opts[:parser].is_a?(Proc)
+      Marshal.dump([http_method, path, opts, last_response, @last_uri, @raw_request])
+    end
+
     private
 
     def http
       connection_adapter.call(uri, options)
     end
 
-    def body
-      options[:body].respond_to?(:to_hash) ? normalize_query(options[:body]) : options[:body]
-    end
-
     def credentials
       (options[:basic_auth] || options[:digest_auth]).to_hash
     end
@@ -205,25 +222,35 @@ module HTTParty
     end
 
     def setup_raw_request
-      @raw_request = http_method.new(request_uri(uri))
-      @raw_request.body = body if body
-      @raw_request.body_stream = options[:body_stream] if options[:body_stream]
       if options[:headers].respond_to?(:to_hash)
         headers_hash = options[:headers].to_hash
-        
-        @raw_request.initialize_http_header(headers_hash)
-        # If the caller specified a header of 'Accept-Encoding', assume they want to 
-        # deal with encoding of content. Disable the internal logic in Net:HTTP
-        # that handles encoding, if the platform supports it.
-        if @raw_request.respond_to?(:decode_content) && (headers_hash.key?('Accept-Encoding') || headers_hash.key?('accept-encoding'))
-          # Using the '[]=' sets decode_content to false
-          @raw_request['accept-encoding'] = @raw_request['accept-encoding']
+      else
+        headers_hash = nil
+      end
+
+      @raw_request = http_method.new(request_uri(uri), headers_hash)
+      @raw_request.body_stream = options[:body_stream] if options[:body_stream]
+
+      if options[:body]
+        body = Body.new(
+          options[:body],
+          query_string_normalizer: query_string_normalizer,
+          force_multipart: options[:multipart]
+        )
+
+        if body.multipart?
+          content_type = "multipart/form-data; boundary=#{body.boundary}"
+          @raw_request['Content-Type'] = content_type
         end
+        @raw_request.body = body.call
       end
-      if options[:basic_auth] && send_authorization_header?        
+
+      @raw_request.instance_variable_set(:@decode_content, decompress_content?)
+
+      if options[:basic_auth] && send_authorization_header?
         @raw_request.basic_auth(username, password)
         @credentials_sent = true
-      end 
+      end
       setup_digest_auth if digest_auth? && response_unauthorized? && response_has_digest_auth_challenge?
     end
 
@@ -231,6 +258,10 @@ module HTTParty
       !!options[:digest_auth]
     end
 
+    def decompress_content?
+      !options[:skip_decompression]
+    end
+
     def response_unauthorized?
       !!last_response && last_response.code == '401'
     end
@@ -240,7 +271,7 @@ module HTTParty
     end
 
     def setup_digest_auth
-      @raw_request.digest_auth(username, password, last_response)      
+      @raw_request.digest_auth(username, password, last_response)
     end
 
     def query_string(uri)
@@ -254,78 +285,15 @@ module HTTParty
         query_string_parts << options[:query] unless options[:query].nil?
       end
 
-      query_string_parts.reject!(&:empty?) unless query_string_parts == [""]
+      query_string_parts.reject!(&:empty?) unless query_string_parts == ['']
       query_string_parts.size > 0 ? query_string_parts.join('&') : nil
     end
 
-    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)
-      if Encoding.name_list.include?(charset)
-        body.force_encoding(charset)
-      else 
-        body
-      end 
-    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)
+    def handle_response(raw_body, &block)
       if response_redirects?
         options[:limit] -= 1
         if options[:logger]
@@ -346,15 +314,26 @@ module HTTParty
         capture_cookies(last_response)
         perform(&block)
       else
-        body ||= last_response.body
-        body = encode_body(body)
-        Response.new(self, last_response, lambda { parse_response(body) }, body: body)
+        raw_body ||= last_response.body
+
+        body = decompress(raw_body, last_response['content-encoding']) unless raw_body.nil?
+
+        unless body.nil?
+          body = encode_text(body, last_response['content-type'])
+
+          if decompress_content?
+            last_response.delete('content-encoding')
+            raw_body = body
+          end
+        end
+
+        Response.new(self, last_response, lambda { parse_response(body) }, body: raw_body)
       end
     end
 
     def handle_host_redirection
       check_duplicate_location_header
-      redirect_path = options[:uri_adapter].parse last_response['location']
+      redirect_path = options[:uri_adapter].parse(last_response['location']).normalize
       return if redirect_path.relative? || path.host == redirect_path.host
       @changed_hosts = true
     end
@@ -367,7 +346,7 @@ module HTTParty
     end
 
     def send_authorization_header?
-      !@changed_hosts      
+      !@changed_hosts
     end
 
     def response_redirects?
@@ -388,7 +367,7 @@ module HTTParty
       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
@@ -423,5 +402,17 @@ module HTTParty
         @credentials_sent = true
       end
     end
+
+    def decompress(body, encoding)
+      Decompressor.new(body, encoding).decompress
+    end
+
+    def encode_text(text, content_type)
+      TextEncoder.new(
+        text,
+        content_type: content_type,
+        assume_utf16_is_big_endian: assume_utf16_is_big_endian
+      ).call
+    end
   end
 end

data/lib/httparty/response/headers.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
 module HTTParty
   class Response #:nodoc:
     class Headers < ::SimpleDelegator
@@ -20,10 +24,10 @@ module HTTParty
       end
 
       def ==(other)
-        if other.is_a?(::Net::HTTPHeader) 
+        if other.is_a?(::Net::HTTPHeader)
           @header == other.instance_variable_get(:@header)
         elsif other.is_a?(Hash)
-          @header == other || @header == Headers.new(other).instance_variable_get(:@header)           
+          @header == other || @header == Headers.new(other).instance_variable_get(:@header)
         end
       end
     end

data/lib/httparty/response.rb

@@ -1,9 +1,17 @@
+# frozen_string_literal: true
+
 module HTTParty
   class Response < Object
     def self.underscore(string)
       string.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
     end
 
+    def self._load(data)
+      req, resp, parsed_resp, resp_body = Marshal.load(data)
+
+      new(req, resp, -> { parsed_resp }, body: resp_body)
+    end
+
     attr_reader :request, :response, :body, :headers
 
     def initialize(request, response, parsed_block, options = {})
@@ -14,7 +22,11 @@ module HTTParty
       @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 = ::HTTParty::Logger.build(
+          request.options[:logger],
+          request.options[:log_level],
+          request.options[:log_format]
+        )
         logger.format(request, self)
       end
 
@@ -29,20 +41,24 @@ module HTTParty
       response.code.to_i
     end
 
+    def http_version
+      response.http_version
+    end
+
     def tap
       yield self
       self
     end
 
     def inspect
-      inspect_id = ::Kernel::format "%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
 
     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", '')
+      name = klass.name.sub('Net::HTTP', '')
       name = "#{underscore(name)}?".to_sym
 
       define_method(name) do
@@ -51,28 +67,46 @@ module HTTParty
     end
 
     # Support old multiple_choice? method from pre 2.0.0 era.
-    if ::RUBY_VERSION >= "2.0.0" && ::RUBY_PLATFORM != "java"
+    if ::RUBY_VERSION >= '2.0.0' && ::RUBY_PLATFORM != 'java'
       alias_method :multiple_choice?, :multiple_choices?
     end
 
+    # Support old status codes method from pre 2.6.0 era.
+    if ::RUBY_VERSION >= '2.6.0' && ::RUBY_PLATFORM != 'java'
+      alias_method :gateway_time_out?,                :gateway_timeout?
+      alias_method :request_entity_too_large?,        :payload_too_large?
+      alias_method :request_time_out?,                :request_timeout?
+      alias_method :request_uri_too_long?,            :uri_too_long?
+      alias_method :requested_range_not_satisfiable?, :range_not_satisfiable?
+    end
+
     def nil?
+      warn_about_nil_deprecation
       response.nil? || response.body.nil? || response.body.empty?
     end
 
-    def to_s      
+    def to_s
       if !response.nil? && !response.body.nil? && response.body.respond_to?(:to_s)
         response.body.to_s
-      else 
+      else
         inspect
       end
     end
 
+    def pretty_print(pp)
+      if !parsed_response.nil? && parsed_response.respond_to?(:pretty_print)
+        parsed_response.pretty_print(pp)
+      else
+        super
+      end
+    end
+
     def display(port=$>)
       if !parsed_response.nil? && parsed_response.respond_to?(:display)
         parsed_response.display(port)
       elsif !response.nil? && !response.body.nil? && response.body.respond_to?(:display)
         response.body.display(port)
-      else 
+      else
         port.write(inspect)
       end
     end
@@ -81,7 +115,11 @@ module HTTParty
       return true if super
       parsed_response.respond_to?(name) || response.respond_to?(name)
     end
-    
+
+    def _dump(_level)
+      Marshal.dump([request, response, parsed_response, body])
+    end
+
     protected
 
     def method_missing(name, *args, &block)
@@ -99,6 +137,19 @@ module HTTParty
         ::Kernel.raise ::HTTParty::ResponseError.new(@response), "Code #{code} - #{body}"
       end
     end
+
+    private
+
+    def warn_about_nil_deprecation
+      trace_line = caller.reject { |line| line.include?('httparty') }.first
+      warning = "[DEPRECATION] HTTParty will no longer override `response#nil?`. " \
+        "This functionality will be removed in future versions. " \
+        "Please, add explicit check `response.body.nil? || response.body.empty?`. " \
+        "For more info refer to: https://github.com/jnunemaker/httparty/issues/568\n" \
+        "#{trace_line}"
+
+      warn(warning)
+    end
   end
 end
 

data/lib/httparty/response_fragment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module HTTParty
+  # Allow access to http_response and code by delegation on fragment
+  class ResponseFragment < SimpleDelegator
+    attr_reader :http_response, :connection
+
+    def code
+      @http_response.code.to_i
+    end
+
+    def initialize(fragment, http_response, connection)
+      @fragment = fragment
+      @http_response = http_response
+      @connection = connection
+      super fragment
+    end
+  end
+end

data/lib/httparty/text_encoder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module HTTParty
+  class TextEncoder
+    attr_reader :text, :content_type, :assume_utf16_is_big_endian
+
+    def initialize(text, assume_utf16_is_big_endian: true, content_type: nil)
+      @text = +text
+      @content_type = content_type
+      @assume_utf16_is_big_endian = assume_utf16_is_big_endian
+    end
+
+    def call
+      if can_encode?
+        encoded_text
+      else
+        text
+      end
+    end
+
+    private
+
+    def can_encode?
+      ''.respond_to?(:encoding) && charset
+    end
+
+    def encoded_text
+      if 'utf-16'.casecmp(charset) == 0
+        encode_utf_16
+      else
+        encode_with_ruby_encoding
+      end
+    end
+
+    def encode_utf_16
+      if text.bytesize >= 2
+        if text.getbyte(0) == 0xFF && text.getbyte(1) == 0xFE
+          return text.force_encoding('UTF-16LE')
+        elsif text.getbyte(0) == 0xFE && text.getbyte(1) == 0xFF
+          return text.force_encoding('UTF-16BE')
+        end
+      end
+
+      if assume_utf16_is_big_endian # option
+        text.force_encoding('UTF-16BE')
+      else
+        text.force_encoding('UTF-16LE')
+      end
+    end
+
+    def encode_with_ruby_encoding
+      # NOTE: This will raise an argument error if the
+      # charset does not exist
+      encoding = Encoding.find(charset)
+      text.force_encoding(encoding.to_s)
+    rescue ArgumentError
+      text
+    end
+
+    def charset
+      return nil if content_type.nil?
+
+      if (matchdata = content_type.match(/;\s*charset\s*=\s*([^=,;"\s]+)/i))
+        return matchdata.captures.first
+      end
+
+      if (matchdata = content_type.match(/;\s*charset\s*=\s*"((\\.|[^\\"])+)"/i))
+        return matchdata.captures.first.gsub(/\\(.)/, '\1')
+      end
+    end
+  end
+end

data/lib/httparty/utils.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module HTTParty
+  module Utils
+    def self.stringify_keys(hash)
+      return hash.transform_keys(&:to_s) if hash.respond_to?(:transform_keys)
+
+      hash.each_with_object({}) do |(key, value), new_hash|
+        new_hash[key.to_s] = value
+      end
+    end
+  end
+end

data/lib/httparty/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTTParty
-  VERSION = "0.15.0"
+  VERSION = '0.21.0'
 end