httparty 0.16.4 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8ea06db7242bc4bea719ac28217cb7a03643277
-  data.tar.gz: 3341968702712ab91fc1348f000337afe1bf4047
+  metadata.gz: 3e555084c3fc85098b7da66339a47958b2383014
+  data.tar.gz: 937364fd6bd11140590f15beb4b324fa89eef30c
 SHA512:
-  metadata.gz: bfd0717ef9adb117bc7568a35648b0bc295d0f92210696a423c268be80b7ef12d06d84d2d94ed33a24d31367fd03c3fae3cabc6afbc5cc5b0446f15f01feff79
-  data.tar.gz: 853d4aa140b4717e36ae0baeeb6c1ba113567242398abd56a944bcf29543f74e3a0a3430c0f8823b9fe9c00d8a4bdb2c3a3ff53c59cf9263e080ac7002013f4e
+  metadata.gz: 0f0a8e29081a7c99e7ebebbe885e717326cbd45930ed096c88d953c7ef0a53e16eec6cdf6f273eaa6dd83e1a2eb42c861e7917c81e267e3085cc709e42fa4506
+  data.tar.gz: 1fcbb78cf1e3b7ede28e10f8de4ac40f34da5d1ec241dbfac9ff432e12f859ffd50457e469c39c3d4351f0a9997e916a1e09cb322fbe363b5e6df1e4ef7284f0

data/.travis.yml

@@ -6,6 +6,6 @@ rvm:
   - 2.3.8
   - 2.4.5
   - 2.5.3
-  - 2.6.0
+  - 2.6.1
 bundler_args: --without development
 before_install: gem install bundler -v '< 2'

data/Changelog.md

@@ -1,3 +1,9 @@
+## 0.17.0
+
+* [Fix encoding of streamed chunk](https://github.com/jnunemaker/httparty/pull/644)
+* [Avoid modifying frozen strings](https://github.com/jnunemaker/httparty/pull/649)
+* [Expose .connection on fragment block param](https://github.com/jnunemaker/httparty/pull/648)
+* [Add support for `Net::HTTP#write_timeout` method (Ruby 2.6.0)](https://github.com/jnunemaker/httparty/pull/647)
 
 ## 0.16.4
 * [Add support for Ruby 2.6](https://github.com/jnunemaker/httparty/pull/636)

data/Gemfile

@@ -17,3 +17,7 @@ group :test do
   gem 'cucumber', '~> 2.3'
   gem 'webmock'
 end
+
+group :development, :test do
+  gem 'pry'
+end

data/docs/README.md

@@ -9,7 +9,7 @@ Makes http fun again!
 ## Parsing JSON
 If the response Content Type is `application/json`, HTTParty will parse the response and return Ruby objects such as a hash or array. The default behavior for parsing JSON will return keys as strings. This can be supressed with the `format` option. To get hash keys as symbols:
 
-```
+```ruby
 response = HTTParty.get('http://example.com', format: :plain)
 JSON.parse response, symbolize_names: true
 ```
@@ -103,4 +103,4 @@ class Client
     # get("resources", verify_peer: false)
   end
 end
-```
+```

data/examples/README.md

@@ -81,3 +81,6 @@
 
 * [Uploading File](body_stream.rb)
   * Uses `body_stream` to upload file
+
+* [Accessing x509 Peer Certificate](peer_cert.rb)
+  * Provides access to the server's TLS certificate

data/examples/peer_cert.rb

@@ -0,0 +1,9 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+
+peer_cert = nil
+HTTParty.get("https://www.example.com") do |fragment|
+  peer_cert ||= fragment.connection.peer_cert
+end
+
+puts "The server's certificate expires #{peer_cert.not_after}"

data/lib/httparty.rb

@@ -14,6 +14,9 @@ require 'httparty/net_digest_auth'
 require 'httparty/version'
 require 'httparty/connection_adapter'
 require 'httparty/logger/logger'
+require 'httparty/request/body'
+require 'httparty/response_fragment'
+require 'httparty/text_encoder'
 
 # @see HTTParty::ClassMethods
 module HTTParty
@@ -170,9 +173,9 @@ module HTTParty
     #     include HTTParty
     #     default_timeout 10
     #   end
-    def default_timeout(t)
-      raise ArgumentError, 'Timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
-      default_options[:timeout] = t
+    def default_timeout(value)
+      validate_timeout_argument(__method__, value)
+      default_options[:timeout] = value
     end
 
     # Allows setting a default open_timeout for all HTTP calls in seconds
@@ -181,9 +184,9 @@ module HTTParty
     #     include HTTParty
     #     open_timeout 10
     #   end
-    def open_timeout(t)
-      raise ArgumentError, 'open_timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
-      default_options[:open_timeout] = t
+    def open_timeout(value)
+      validate_timeout_argument(__method__, value)
+      default_options[:open_timeout] = value
     end
 
     # Allows setting a default read_timeout for all HTTP calls in seconds
@@ -192,11 +195,24 @@ module HTTParty
     #     include HTTParty
     #     read_timeout 10
     #   end
-    def read_timeout(t)
-      raise ArgumentError, 'read_timeout must be an integer or float' unless t && (t.is_a?(Integer) || t.is_a?(Float))
-      default_options[:read_timeout] = t
+    def read_timeout(value)
+      validate_timeout_argument(__method__, value)
+      default_options[:read_timeout] = value
     end
 
+    # Allows setting a default write_timeout for all HTTP calls in seconds
+    # Supported by Ruby > 2.6.0
+    #
+    #   class Foo
+    #     include HTTParty
+    #     write_timeout 10
+    #   end
+    def write_timeout(value)
+      validate_timeout_argument(__method__, value)
+      default_options[:write_timeout] = value
+    end
+
+
     # Set an output stream for debugging, defaults to $stderr.
     # The output stream is passed on to Net::HTTP#set_debug_output.
     #
@@ -560,6 +576,10 @@ module HTTParty
 
     private
 
+    def validate_timeout_argument(timeout_type, value)
+      raise ArgumentError, "#{ timeout_type } must be an integer or float" unless value && (value.is_a?(Integer) || value.is_a?(Float))
+    end
+
     def ensure_method_maintained_across_redirects(options)
       unless options.key?(:maintain_method_across_redirects)
         options[:maintain_method_across_redirects] = true

data/lib/httparty/connection_adapter.rb

@@ -42,6 +42,7 @@ module HTTParty
   # * :+timeout+: timeout in seconds
   # * :+open_timeout+: http connection open_timeout in seconds, overrides timeout if set
   # * :+read_timeout+: http connection read_timeout in seconds, overrides timeout if set
+  # * :+write_timeout+: http connection write_timeout in seconds, overrides timeout if set (Ruby >= 2.6.0 required)
   # * :+debug_output+: see HTTParty::ClassMethods.debug_output.
   # * :+cert_store+: contains certificate data. see method 'attach_ssl_certificates'
   # * :+pem+: contains pem client certificate data. see method 'attach_ssl_certificates'
@@ -113,19 +114,29 @@ module HTTParty
 
       attach_ssl_certificates(http, options)
 
-      if options[:timeout] && (options[:timeout].is_a?(Integer) || options[:timeout].is_a?(Float))
+      if add_timeout?(options[:timeout])
         http.open_timeout = options[:timeout]
         http.read_timeout = options[:timeout]
+
+        from_ruby_version('2.6.0', option: :write_timeout, warn: false) do
+          http.write_timeout = options[:timeout]
+        end
       end
 
-      if options[:read_timeout] && (options[:read_timeout].is_a?(Integer) || options[:read_timeout].is_a?(Float))
+      if add_timeout?(options[:read_timeout])
         http.read_timeout = options[:read_timeout]
       end
 
-      if options[:open_timeout] && (options[:open_timeout].is_a?(Integer) || options[:open_timeout].is_a?(Float))
+      if add_timeout?(options[:open_timeout])
         http.open_timeout = options[:open_timeout]
       end
 
+      if add_timeout?(options[:write_timeout])
+        from_ruby_version('2.6.0', option: :write_timeout) do
+          http.write_timeout = options[:write_timeout]
+        end
+      end
+
       if options[:debug_output]
         http.set_debug_output(options[:debug_output])
       end
@@ -138,18 +149,14 @@ module HTTParty
       #
       # @see https://bugs.ruby-lang.org/issues/6617
       if options[:local_host]
-        if RUBY_VERSION >= "2.0.0"
+        from_ruby_version('2.0.0', option: :local_host) do
           http.local_host = options[:local_host]
-        else
-          Kernel.warn("Warning: option :local_host requires Ruby version 2.0 or later")
         end
       end
 
       if options[:local_port]
-        if RUBY_VERSION >= "2.0.0"
+        from_ruby_version('2.0.0', option: :local_port) do
           http.local_port = options[:local_port]
-        else
-          Kernel.warn("Warning: option :local_port requires Ruby version 2.0 or later")
         end
       end
 
@@ -158,6 +165,18 @@ module HTTParty
 
     private
 
+    def from_ruby_version(ruby_version, option: nil, warn: true)
+      if RUBY_VERSION >= ruby_version
+        yield
+      elsif warn
+        Kernel.warn("Warning: option #{ option } requires Ruby version #{ ruby_version } or later")
+      end
+    end
+
+    def add_timeout?(timeout)
+      timeout && (timeout.is_a?(Integer) || timeout.is_a?(Float))
+    end
+
     def clean_host(host)
       strip_ipv6_brackets(host)
     end

data/lib/httparty/request.rb

@@ -1,6 +1,4 @@
 require 'erb'
-require 'httparty/request/body'
-require 'httparty/fragment_with_response'
 
 module HTTParty
   class Request #:nodoc:
@@ -142,21 +140,22 @@ 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 FragmentWithResponse.new(fragment, http_response)
+            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)
@@ -273,74 +272,10 @@ module HTTParty
       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)
-      # NOTE: This will raise an argument error if the
-      # charset does not exist
-      encoding = Encoding.find(charset)
-      body.force_encoding(encoding.to_s)
-    rescue ArgumentError
-      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
@@ -363,7 +298,7 @@ module HTTParty
         perform(&block)
       else
         body ||= last_response.body
-        body = body.nil? ? body : encode_body(body)
+        body = body.nil? ? body : encode_text(body, last_response['content-type'])
         Response.new(self, last_response, lambda { parse_response(body) }, body: body)
       end
     end
@@ -439,5 +374,13 @@ module HTTParty
         @credentials_sent = true
       end
     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.rb

@@ -39,6 +39,10 @@ module HTTParty
       response.code.to_i
     end
 
+    def http_version
+      response.http_version
+    end
+
     def tap
       yield self
       self

data/lib/httparty/{fragment_with_response.rb → response_fragment.rb}

@@ -2,18 +2,17 @@ require 'delegate'
 
 module HTTParty
   # Allow access to http_response and code by delegation on fragment
-  class FragmentWithResponse < SimpleDelegator
-    extend Forwardable
-
-    attr_reader :http_response
+  class ResponseFragment < SimpleDelegator
+    attr_reader :http_response, :connection
 
     def code
       @http_response.code.to_i
     end
 
-    def initialize(fragment, http_response)
+    def initialize(fragment, http_response, connection)
       @fragment = fragment
       @http_response = http_response
+      @connection = connection
       super fragment
     end
   end

data/lib/httparty/text_encoder.rb

@@ -0,0 +1,70 @@
+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.dup
+      @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