httparty 0.15.0 → 0.21.0

data/examples/logging.rb

@@ -3,7 +3,7 @@ require File.join(dir, 'httparty')
 require 'logger'
 require 'pp'
 
-my_logger = Logger.new "httparty.log"
+my_logger = Logger.new STDOUT
 
 my_logger.info "Logging can be used on the main HTTParty class. It logs redirects too."
 HTTParty.get "http://google.com", logger: my_logger
@@ -14,7 +14,7 @@ my_logger.info "It can be used also on a custom class."
 
 class Google
   include HTTParty
-  logger ::Logger.new "httparty.log"
+  logger ::Logger.new STDOUT
 end
 
 Google.get "http://google.com"
@@ -30,7 +30,7 @@ my_logger.info '*' * 70
 my_logger.info "These configs are also available on custom classes."
 class Google
   include HTTParty
-  logger ::Logger.new("httparty.log"), :debug, :curl
+  logger ::Logger.new(STDOUT), :debug, :curl
 end
 
 Google.get "http://google.com"

data/examples/microsoft_graph.rb

@@ -0,0 +1,52 @@
+require 'httparty'
+
+class MicrosoftGraph
+  MS_BASE_URL = "https://login.microsoftonline.com".freeze
+  TOKEN_REQUEST_PATH = "oauth2/v2.0/token".freeze
+
+  def initialize(tenant_id)
+    @tenant_id = tenant_id
+  end
+
+  # Make a request to the Microsoft Graph API, for instance https://graph.microsoft.com/v1.0/users
+  def request(url)
+    return false unless (token = bearer_token)
+
+    response = HTTParty.get(
+      url,
+      headers: {
+        Authorization: "Bearer #{token}"
+      }
+    )
+
+    return false unless response.code == 200
+
+    return JSON.parse(response.body)
+  end
+
+  private
+
+  # A post to the Microsoft Graph to get a bearer token for the specified tenant.  In this example
+  # our Rails application has already been given permission to request these tokens by the admin of
+  # the specified tenant_id.
+  #
+  # See here for more information https://developer.microsoft.com/en-us/graph/docs/concepts/auth_v2_service
+  #
+  # This request also makes use of the multipart/form-data post body.
+  def bearer_token
+    response = HTTParty.post(
+      "#{MS_BASE_URL}/#{@tenant_id}/#{TOKEN_REQUEST_PATH}",
+      multipart: true,
+      body: {
+        client_id: Rails.application.credentials[Rails.env.to_sym][:microsoft_client_id],
+        client_secret: Rails.application.credentials[Rails.env.to_sym][:microsoft_client_secret],
+        scope: 'https://graph.microsoft.com/.default',
+        grant_type: 'client_credentials'
+      }
+    )
+
+    return false unless response.code == 200
+
+    JSON.parse(response.body)['access_token']
+  end
+end

data/examples/multipart.rb

@@ -0,0 +1,22 @@
+# If you are uploading file in params, multipart will used as content-type automatically
+
+HTTParty.post(
+  'http://localhost:3000/user',
+  body: {
+    name: 'Foo Bar',
+    email: 'example@email.com',
+    avatar: File.open('/full/path/to/avatar.jpg')
+  }
+)
+
+
+# However, you can force it yourself
+
+HTTParty.post(
+  'http://localhost:3000/user',
+  multipart: true,
+  body: {
+    name: 'Foo Bar',
+    email: 'example@email.com'
+  }
+)

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/examples/stream_download.rb

@@ -9,8 +9,14 @@ url = "https://cdn.kernel.org/pub/linux/kernel/v4.x/#{filename}"
 
 File.open(filename, "w") do |file|
   response = HTTParty.get(url, stream_body: true) do |fragment|
-    print "."
-    file.write(fragment)
+    if [301, 302].include?(fragment.code)
+      print "skip writing for redirect"
+    elsif fragment.code == 200
+      print "."
+      file.write(fragment)
+    else
+      raise StandardError, "Non-success status code while streaming #{fragment.code}"
+    end
   end
 end
 puts

data/httparty.gemspec

@@ -9,19 +9,22 @@ Gem::Specification.new do |s|
   s.licenses    = ['MIT']
   s.authors     = ["John Nunemaker", "Sandro Turriate"]
   s.email       = ["nunemaker@gmail.com"]
-  s.homepage    = "http://jnunemaker.github.com/httparty"
+  s.homepage    = "https://github.com/jnunemaker/httparty"
   s.summary     = 'Makes http fun! Also, makes consuming restful web services dead easy.'
   s.description = 'Makes http fun! Also, makes consuming restful web services dead easy.'
 
-  s.required_ruby_version     = '>= 2.0.0'
+  s.required_ruby_version     = '>= 2.3.0'
 
   s.add_dependency 'multi_xml', ">= 0.5.2"
+  s.add_dependency 'mini_mime', ">= 1.0.0"
 
   # If this line is removed, all hard partying will cease.
   s.post_install_message = "When you HTTParty, you must party hard!"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  all_files = `git ls-files`.split("\n")
+  test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.files         = all_files - test_files
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 end

data/lib/httparty/connection_adapter.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module HTTParty
   # Default connection adapter that returns a new Net::HTTP each time
   #
   # == Custom Connection Factories
   #
   # If you like to implement your own connection adapter, subclassing
-  # HTTPParty::ConnectionAdapter will make it easier. Just override
+  # HTTParty::ConnectionAdapter will make it easier. Just override
   # the #connection method. The uri and options attributes will have
   # all the info you need to construct your http connection. Whatever
   # you return from your connection method needs to adhere to the
@@ -38,12 +40,13 @@ module HTTParty
   # in the #options attribute. It is up to you to interpret them within your
   # connection adapter. Take a look at the implementation of
   # HTTParty::ConnectionAdapter#connection for examples of how they are used.
-  # The keys used in options are 
+  # The keys used in options are
   # * :+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' 
+  # * :+cert_store+: contains certificate data. see method 'attach_ssl_certificates'
   # * :+pem+: contains pem client certificate data. see method 'attach_ssl_certificates'
   # * :+p12+: contains PKCS12 client client certificate data.  see method 'attach_ssl_certificates'
   # * :+verify+: verify the server’s certificate against the ca certificate.
@@ -77,6 +80,12 @@ module HTTParty
       new(uri, options).connection
     end
 
+    def self.default_cert_store
+      @default_cert_store ||= OpenSSL::X509::Store.new.tap do |cert_store|
+        cert_store.set_default_paths
+      end
+    end
+
     attr_reader :uri, :options
 
     def initialize(uri, options = {})
@@ -91,7 +100,14 @@ module HTTParty
       host = clean_host(uri.host)
       port = uri.port || (uri.scheme == 'https' ? 443 : 80)
       if options.key?(:http_proxyaddr)
-        http = Net::HTTP.new(host, port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
+        http = Net::HTTP.new(
+          host,
+          port,
+          options[:http_proxyaddr],
+          options[:http_proxyport],
+          options[:http_proxyuser],
+          options[:http_proxypass]
+        )
       else
         http = Net::HTTP.new(host, port)
       end
@@ -100,19 +116,35 @@ 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 add_max_retries?(options[:max_retries])
+        from_ruby_version('2.5.0', option: :max_retries) do
+          http.max_retries = options[:max_retries]
+        end
+      end
+
       if options[:debug_output]
         http.set_debug_output(options[:debug_output])
       end
@@ -125,18 +157,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
 
@@ -145,6 +173,22 @@ 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 add_max_retries?(max_retries)
+      max_retries && max_retries.is_a?(Integer) && max_retries >= 0
+    end
+
     def clean_host(host)
       strip_ipv6_brackets(host)
     end
@@ -169,8 +213,7 @@ module HTTParty
             http.cert_store = options[:cert_store]
           else
             # Use the default cert store by default, i.e. system ca certs
-            http.cert_store = OpenSSL::X509::Store.new
-            http.cert_store.set_default_paths
+            http.cert_store = self.class.default_cert_store
           end
         else
           http.verify_mode = OpenSSL::SSL::VERIFY_NONE
@@ -180,7 +223,7 @@ module HTTParty
         # Note: options[:pem] must contain the content of a PEM file having the private key appended
         if options[:pem]
           http.cert = OpenSSL::X509::Certificate.new(options[:pem])
-          http.key = OpenSSL::PKey::RSA.new(options[:pem], options[:pem_password])
+          http.key = OpenSSL::PKey.read(options[:pem], options[:pem_password])
           http.verify_mode = verify_ssl_certificate? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
         end
 

data/lib/httparty/cookie_hash.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 class HTTParty::CookieHash < Hash #:nodoc:
-  CLIENT_COOKIES = %w(path expires domain path secure httponly)
+  CLIENT_COOKIES = %w(path expires domain path secure httponly samesite)
 
-  def add_cookies(value)
-    case value
+  def add_cookies(data)
+    case data
     when Hash
-      merge!(value)
+      merge!(data)
     when String
-      value.split('; ').each do |cookie|
-        array = cookie.split('=', 2)
-        self[array[0].to_sym] = array[1]
+      data.split('; ').each do |cookie|
+        key, value = cookie.split('=', 2)
+        self[key.to_sym] = value if key
       end
     else
       raise "add_cookies only takes a Hash or a String"
@@ -16,6 +18,6 @@ class HTTParty::CookieHash < Hash #:nodoc:
   end
 
   def to_cookie_string
-    reject { |k, v| CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
+    select { |k, v| !CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join('; ')
   end
 end

data/lib/httparty/decompressor.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module HTTParty
+  # Decompresses the response body based on the Content-Encoding header.
+  #
+  # Net::HTTP automatically decompresses Content-Encoding values "gzip" and "deflate".
+  # This class will handle "br" (Brotli) and "compress" (LZW) if the requisite
+  # gems are installed. Otherwise, it returns nil if the body data cannot be
+  # decompressed.
+  #
+  # @abstract Read the HTTP Compression section for more information.
+  class Decompressor
+
+    # "gzip" and "deflate" are handled by Net::HTTP
+    # hence they do not need to be handled by HTTParty
+    SupportedEncodings = {
+      'none'     => :none,
+      'identity' => :none,
+      'br'       => :brotli,
+      'compress' => :lzw,
+      'zstd'     => :zstd
+    }.freeze
+
+    # The response body of the request
+    # @return [String]
+    attr_reader :body
+
+    # The Content-Encoding algorithm used to encode the body
+    # @return [Symbol] e.g. :gzip
+    attr_reader :encoding
+
+    # @param [String] body - the response body of the request
+    # @param [Symbol] encoding - the Content-Encoding algorithm used to encode the body
+    def initialize(body, encoding)
+      @body = body
+      @encoding = encoding
+    end
+
+    # Perform decompression on the response body
+    # @return [String] the decompressed body
+    # @return [nil] when the response body is nil or cannot decompressed
+    def decompress
+      return nil if body.nil?
+      return body if encoding.nil? || encoding.strip.empty?
+
+      if supports_encoding?
+        decompress_supported_encoding
+      else
+        nil
+      end
+    end
+
+    protected
+
+    def supports_encoding?
+      SupportedEncodings.keys.include?(encoding)
+    end
+
+    def decompress_supported_encoding
+      method = SupportedEncodings[encoding]
+      if respond_to?(method, true)
+        send(method)
+      else
+        raise NotImplementedError, "#{self.class.name} has not implemented a decompression method for #{encoding.inspect} encoding."
+      end
+    end
+
+    def none
+      body
+    end
+
+    def brotli
+      return nil unless defined?(::Brotli)
+      begin
+        ::Brotli.inflate(body)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def lzw
+      begin
+        if defined?(::LZWS::String)
+          ::LZWS::String.decompress(body)
+        elsif defined?(::LZW::Simple)
+          ::LZW::Simple.new.decompress(body)
+        end
+      rescue StandardError
+        nil
+      end
+    end
+
+    def zstd
+      return nil unless defined?(::Zstd)
+      begin
+        ::Zstd.decompress(body)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/httparty/exceptions.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module HTTParty
-  # @abstact Exceptions raised by HTTParty inherit from Error
+  # @abstract Exceptions raised by HTTParty inherit from Error
   class Error < StandardError; end
 
   # Exception raised when you attempt to set a non-existent format
@@ -20,6 +22,7 @@ module HTTParty
     # @param [Net::HTTPResponse]
     def initialize(response)
       @response = response
+      super(response)
     end
   end
 

data/lib/httparty/hash_conversions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erb'
 
 module HTTParty
@@ -24,32 +26,46 @@ module HTTParty
     #
     # @example normalize_param(:name, "Bob Jones") #=> "name=Bob%20Jones&"
     def self.normalize_param(key, value)
-      param = ''
+      normalized_keys = normalize_keys(key, value)
+
+      normalized_keys.flatten.each_slice(2).inject(''.dup) do |string, (k, v)|
+        string << "#{ERB::Util.url_encode(k)}=#{ERB::Util.url_encode(v.to_s)}&"
+      end
+    end
+
+    def self.normalize_keys(key, value)
       stack = []
+      normalized_keys = []
 
       if value.respond_to?(:to_ary)
-        param << if value.empty?
-                   "#{key}[]=&"
-                 else
-                   value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
-                 end
+        if value.empty?
+          normalized_keys << ["#{key}[]", '']
+        else
+          normalized_keys = value.to_ary.flat_map do |element|
+            normalize_keys("#{key}[]", element)
+          end
+        end
       elsif value.respond_to?(:to_hash)
         stack << [key, value.to_hash]
       else
-        param << "#{key}=#{ERB::Util.url_encode(value.to_s)}&"
+        normalized_keys << [key.to_s, value]
       end
 
       stack.each do |parent, hash|
-        hash.each do |k, v|
-          if v.respond_to?(:to_hash)
-            stack << ["#{parent}[#{k}]", v.to_hash]
+        hash.each do |child_key, child_value|
+          if child_value.respond_to?(:to_hash)
+            stack << ["#{parent}[#{child_key}]", child_value.to_hash]
+          elsif child_value.respond_to?(:to_ary)
+            child_value.to_ary.each do |v|
+              normalized_keys << normalize_keys("#{parent}[#{child_key}][]", v).flatten
+            end
           else
-            param << normalize_param("#{parent}[#{k}]", v)
+            normalized_keys << normalize_keys("#{parent}[#{child_key}]", child_value).flatten
           end
         end
       end
 
-      param
+      normalized_keys
     end
   end
 end

data/lib/httparty/headers_processor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module HTTParty
+  class HeadersProcessor
+    attr_reader :headers, :options
+
+    def initialize(headers, options)
+      @headers = headers
+      @options = options
+    end
+
+    def call
+      return unless options[:headers]
+
+      options[:headers] = headers.merge(options[:headers]) if headers.any?
+      options[:headers] = Utils.stringify_keys(process_dynamic_headers)
+    end
+
+    private
+
+    def process_dynamic_headers
+      options[:headers].each_with_object({}) do |header, processed_headers|
+        key, value = header
+        processed_headers[key] = if value.respond_to?(:call)
+                                   value.arity == 0 ? value.call : value.call(options)
+                                 else
+                                   value
+                                 end
+      end
+    end
+  end
+end

data/lib/httparty/logger/apache_formatter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module HTTParty
   module Logger
     class ApacheFormatter #:nodoc:
       TAG_NAME = HTTParty.name
 
-      attr_accessor :level, :logger, :current_time
+      attr_accessor :level, :logger
 
       def initialize(logger, level)
         @logger = logger
@@ -11,11 +13,34 @@ module HTTParty
       end
 
       def format(request, response)
-        current_time   = Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
-        http_method    = request.http_method.name.split("::").last.upcase
-        path           = request.path.to_s
-        content_length = response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
-        @logger.send @level, "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
+        @request = request
+        @response = response
+
+        logger.public_send level, message
+      end
+
+      private
+
+      attr_reader :request, :response
+
+      def message
+        "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
+      end
+
+      def current_time
+        Time.now.strftime('%Y-%m-%d %H:%M:%S %z')
+      end
+
+      def http_method
+        request.http_method.name.split('::').last.upcase
+      end
+
+      def path
+        request.path.to_s
+      end
+
+      def content_length
+        response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
       end
     end
   end

data/lib/httparty/logger/curl_formatter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module HTTParty
   module Logger
     class CurlFormatter #:nodoc:
       TAG_NAME = HTTParty.name
-      OUT      = '>'.freeze
-      IN       = '<'.freeze
+      OUT      = '>'
+      IN       = '<'
 
       attr_accessor :level, :logger
 
@@ -20,7 +22,7 @@ module HTTParty
         log_request
         log_response
 
-        logger.send level, messages.join("\n")
+        logger.public_send level, messages.join("\n")
       end
 
       private
@@ -44,7 +46,7 @@ module HTTParty
       end
 
       def log_url
-        http_method = request.http_method.name.split("::").last.upcase
+        http_method = request.http_method.name.split('::').last.upcase
         uri = if request.options[:base_uri]
                 request.options[:base_uri] + request.path.path
               else
@@ -80,11 +82,11 @@ module HTTParty
       end
 
       def log(direction, line = '')
-        messages << "[#{TAG_NAME}] [#{time}] #{direction} #{line}"
+        messages << "[#{TAG_NAME}] [#{current_time}] #{direction} #{line}"
       end
 
-      def time
-        @time ||= Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
+      def current_time
+        Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
       end
     end
   end