httparty 0.10.0 → 0.14.0

data/features/digest_authentication.feature

@@ -18,3 +18,13 @@ Feature:  Digest Authentication
        | username | password   |
        | jcash    | maninblack |
     Then the return value should match 'Digest Authenticated Page'
+
+  Scenario: Passing proper credentials to a page requiring Digest Authentication using md5-sess algorithm
+    Given a remote service that returns 'Digest Authenticated Page Using MD5-sess'
+    And that service is accessed at the path '/digest_auth.html'
+    And that service is protected by MD5-sess Digest Authentication
+    And that service requires the username 'jcash' with the password 'maninblack'
+    When I call HTTParty#get with '/digest_auth.html' and a digest_auth hash:
+       | username | password   |
+       | jcash    | maninblack |
+    Then the return value should match 'Digest Authenticated Page Using MD5-sess'

data/features/handles_compressed_responses.feature

@@ -17,3 +17,11 @@ Feature: Handles Compressed Responses
     And that service is accessed at the path '/gzip_service.html'
     When I call HTTParty#get with '/gzip_service.html'
     Then the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: Supports HEAD request with gzip encoding
+    Given a remote gzip service
+    And that service is accessed at the path '/gzip_head.gz.js'
+    When I call HTTParty#head with '/gzip_head.gz.js'
+    Then it should return a response with a 200 response code
+    Then it should return a response with a gzip content-encoding
+    Then it should return a response with a blank body

data/features/handles_multiple_formats.feature

@@ -14,6 +14,21 @@ Feature: Handles Multiple Formats
     Then it should return a String
     And the return value should match '<h1>Some HTML</h1>'
 
+  Scenario: A CSV service
+    Given a remote service that returns:
+      """
+      "Last Name","Name"
+      "jennings","waylon"
+      "cash","johnny"
+      """
+    And that service is accessed at the path '/service.csv'
+    And the response from the service has a Content-Type of 'application/csv'
+    When I call HTTParty#get with '/service.csv'
+    Then it should return an Array equaling:
+      | Last Name | Name   |
+      | jennings  | waylon |
+      | cash      | johnny |
+
   Scenario: A JSON service
     Given a remote service that returns '{ "jennings": "waylon", "cash": "johnny" }'
     And that service is accessed at the path '/service.json'
@@ -32,3 +47,11 @@ Feature: Handles Multiple Formats
     Then it should return a Hash equaling:
        | key    | value           |
        | singer | waylon jennings |
+
+  Scenario: A Javascript remote file
+    Given a remote service that returns '$(function() { alert("hi"); });'
+    And that service is accessed at the path '/service.js'
+    And the response from the service has a Content-Type of 'application/javascript'
+    When I call HTTParty#get with '/service.js'
+    Then it should return a String
+    And the return value should match '$(function() { alert("hi"); });'

data/features/steps/env.rb

@@ -1,22 +1,27 @@
 require 'mongrel'
 require './lib/httparty'
-require 'spec/expectations'
+require 'rspec/expectations'
+require 'aruba/cucumber'
 
-Before do
-  def new_port
-    server = TCPServer.new('0.0.0.0', nil)
-    port = server.addr[1]
-  ensure
-    server.close
-  end
-
-  port = ENV["HTTPARTY_PORT"] || new_port
+def run_server(port)
   @host_and_port = "0.0.0.0:#{port}"
   @server = Mongrel::HttpServer.new("0.0.0.0", port)
   @server.run
   @request_options = {}
 end
 
+def new_port
+  server = TCPServer.new('0.0.0.0', nil)
+  port = server.addr[1]
+ensure
+  server.close
+end
+
+Before('~@command_line') do
+  port = ENV["HTTPARTY_PORT"] || new_port
+  run_server(port)
+end
+
 After do
-  @server.stop
+  @server.stop if @server
 end

data/features/steps/httparty_response_steps.rb

@@ -1,26 +1,56 @@
-Then /it should return an? (\w+)$/ do |class_string|
-  @response_from_httparty.should be_an_instance_of(class_string.class)
+# Not needed anymore in ruby 2.0, but needed to resolve constants
+# in nested namespaces. This is taken from rails :)
+def constantize(camel_cased_word)
+  names = camel_cased_word.split('::')
+  names.shift if names.empty? || names.first.empty?
+
+  constant = Object
+  names.each do |name|
+    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+  end
+  constant
+end
+
+Then /it should return an? ([\w\:]+)$/ do |class_string|
+  expect(@response_from_httparty.parsed_response).to be_a(Object.const_get(class_string))
 end
 
 Then /the return value should match '(.*)'/ do |expected_text|
-  @response_from_httparty.should eql(expected_text)
+  expect(@response_from_httparty.parsed_response).to eq(expected_text)
 end
 
 Then /it should return a Hash equaling:/ do |hash_table|
-  @response_from_httparty.should be_an_instance_of(Hash)
-  @response_from_httparty.keys.length.should eql(hash_table.rows.length)
+  expect(@response_from_httparty.parsed_response).to be_a(Hash)
+  expect(@response_from_httparty.keys.length).to eq(hash_table.rows.length)
   hash_table.hashes.each do |pair|
     key, value = pair["key"], pair["value"]
-    @response_from_httparty.keys.should include(key)
-    @response_from_httparty[key].should eql(value)
+    expect(@response_from_httparty.keys).to include(key)
+    expect(@response_from_httparty[key]).to eq(value)
   end
 end
 
+Then /it should return an Array equaling:/ do |array|
+  expect(@response_from_httparty.parsed_response).to be_a(Array)
+  expect(@response_from_httparty.parsed_response).to eq(array.raw)
+end
+
 Then /it should return a response with a (\d+) response code/ do |code|
-  @response_from_httparty.code.should eql(code.to_i)
+  expect(@response_from_httparty.code).to eq(code.to_i)
+end
+
+Then /it should return a response with a (.*) content\-encoding$/ do |content_type|
+  expect(@response_from_httparty.headers['content-encoding']).to eq('gzip')
+end
+
+Then /it should return a response with a blank body$/ do
+  expect(@response_from_httparty.body).to be_nil
 end
 
 Then /it should raise (?:an|a) ([\w:]+) exception/ do |exception|
-  @exception_from_httparty.should_not be_nil
-  @exception_from_httparty.class.name.should eql(exception)
+  expect(@exception_from_httparty).to_not be_nil
+  expect(@exception_from_httparty).to be_a constantize(exception)
+end
+
+Then /it should not raise (?:an|a) ([\w:]+) exception/ do |exception|
+  expect(@exception_from_httparty).to be_nil
 end

data/features/steps/httparty_steps.rb

@@ -2,6 +2,14 @@ When /^I set my HTTParty timeout option to (\d+)$/ do |timeout|
   @request_options[:timeout] = timeout.to_i
 end
 
+When /^I set my HTTParty open_timeout option to (\d+)$/ do |timeout|
+  @request_options[:open_timeout] = timeout.to_i
+end
+
+When /^I set my HTTParty read_timeout option to (\d+)$/ do |timeout|
+  @request_options[:read_timeout] = timeout.to_i
+end
+
 When /I call HTTParty#get with '(.*)'$/ do |url|
   begin
     @response_from_httparty = HTTParty.get("http://#{@host_and_port}#{url}", @request_options)
@@ -10,11 +18,19 @@ When /I call HTTParty#get with '(.*)'$/ do |url|
   end
 end
 
+When /^I call HTTParty#head with '(.*)'$/ do |url|
+  begin
+    @response_from_httparty = HTTParty.head("http://#{@host_and_port}#{url}", @request_options)
+  rescue HTTParty::RedirectionTooDeep, Timeout::Error => e
+    @exception_from_httparty = e
+  end
+end
+
 When /I call HTTParty#get with '(.*)' and a basic_auth hash:/ do |url, auth_table|
   h = auth_table.hashes.first
   @response_from_httparty = HTTParty.get(
     "http://#{@host_and_port}#{url}",
-    :basic_auth => { :username => h["username"], :password => h["password"] }
+    basic_auth: { username: h["username"], password: h["password"] }
   )
 end
 
@@ -22,6 +38,6 @@ When /I call HTTParty#get with '(.*)' and a digest_auth hash:/ do |url, auth_tab
   h = auth_table.hashes.first
   @response_from_httparty = HTTParty.get(
     "http://#{@host_and_port}#{url}",
-    :digest_auth => { :username => h["username"], :password => h["password"] }
+    digest_auth: { username: h["username"], password: h["password"] }
   )
-end
+end

data/features/steps/mongrel_helper.rb

@@ -10,14 +10,14 @@ class BasicMongrelHandler < Mongrel::HttpHandler
   end
 
   def process(request, response)
-    instance_eval &preprocessor if preprocessor
+    instance_eval(&preprocessor) if preprocessor
     reply_with(response, response_code, response_body)
   end
 
   def reply_with(response, code, response_body)
     response.start(code) do |head, body|
       head["Content-Type"] = content_type
-      custom_headers.each { |k,v| head[k] = v }
+      custom_headers.each { |k, v| head[k] = v }
       body.write(response_body)
     end
   end
@@ -88,6 +88,39 @@ module DigestAuthentication
   end
 end
 
+module DigestAuthenticationUsingMD5Sess
+  NONCE = 'nonce'
+  REALM = 'testrealm@host.com'
+  QOP = 'auth,auth-int'
+  def self.extended(base)
+    base.custom_headers["WWW-Authenticate"] = %(Digest realm="#{REALM}",qop="#{QOP}",algorithm="MD5-sess",nonce="#{NONCE}",opaque="opaque"')
+  end
+  
+  def process(request, response)
+    if authorized?(request)
+      super
+    else
+      reply_with(response, 401, "Incorrect.  You have 20 seconds to comply.")
+    end
+  end
+  
+  def md5(str)
+    Digest::MD5.hexdigest(str)
+  end
+  
+  def authorized?(request)
+    auth = request.params["HTTP_AUTHORIZATION"]
+    params = {}
+    auth.to_s.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }.gsub(/(\w+)=([^,]*)/) { params[$1] = $2 }
+    a1a = [@username,REALM,@password].join(':')
+    a1 = [md5(a1a),NONCE,params['cnonce'] ].join(':')
+    a2 = [ request.params["REQUEST_METHOD"], request.params["REQUEST_URI"] ] .join(':')
+    expected_response = md5( [md5(a1), NONCE, params['nc'], params['cnonce'], QOP, md5(a2)].join(':') )
+    expected_response == params['response']
+  end
+end
+
+
 def new_mongrel_redirector(target_url, relative_path = false)
   target_url = "http://#{@host_and_port}#{target_url}" unless relative_path
   Mongrel::RedirectHandler.new(target_url)

data/features/steps/remote_service_steps.rb

@@ -1,6 +1,11 @@
 Given /a remote service that returns '(.*)'/ do |response_body|
   @handler = BasicMongrelHandler.new
-  Given "the response from the service has a body of '#{response_body}'"
+  step "the response from the service has a body of '#{response_body}'"
+end
+
+Given /^a remote service that returns:$/ do |response_body|
+  @handler = BasicMongrelHandler.new
+  @handler.response_body = response_body
 end
 
 Given /a remote service that returns a (\d+) status code/ do |code|
@@ -12,15 +17,22 @@ Given /that service is accessed at the path '(.*)'/ do |path|
   @server.register(path, @handler)
 end
 
-Given /^that service takes (\d+) seconds to generate a response$/ do |time|
-  @server_response_time = time.to_i
-  @handler.preprocessor = Proc.new { sleep time.to_i }
+Given /^that service takes (\d+) (.*) to generate a response$/ do |time, unit|
+  time = time.to_i
+  time *= 60 if unit =~ /minute/
+  @server_response_time = time
+  @handler.preprocessor = proc { sleep time }
 end
 
 Given /^a remote deflate service$/ do
   @handler = DeflateHandler.new
 end
 
+Given /^a remote deflate service on port '(\d+)'/ do |port|
+  run_server(port)
+  @handler = DeflateHandler.new
+end
+
 Given /^a remote gzip service$/ do
   @handler = GzipHandler.new
 end
@@ -45,16 +57,27 @@ Given /that service is protected by Digest Authentication/ do
   @handler.extend DigestAuthentication
 end
 
+Given /that service is protected by MD5-sess Digest Authentication/ do
+  @handler.extend DigestAuthenticationUsingMD5Sess
+end
+
 Given /that service requires the username '(.*)' with the password '(.*)'/ do |username, password|
   @handler.username = username
   @handler.password = password
 end
 
+# customize aruba cucumber step
+Then /^the output should contain '(.*)'$/ do |expected|
+  expect(all_commands.map(&:output).join("\n")).to match_output_string(expected)
+end
+
 Given /a restricted page at '(.*)'/ do |url|
-  Given "a remote service that returns 'A response I will never see'"
-  And "that service is accessed at the path '#{url}'"
-  And "that service is protected by Basic Authentication"
-  And "that service requires the username 'something' with the password 'secret'"
+  steps "
+    Given a remote service that returns 'A response I will never see'
+    And that service is accessed at the path '#{url}'
+    And that service is protected by Basic Authentication
+    And that service requires the username 'something' with the password 'secret'
+  "
 end
 
 # This joins the server thread, and halts cucumber, so you can actually hit the

data/features/supports_read_timeout_option.feature

@@ -0,0 +1,13 @@
+Feature: Supports the read timeout option
+  In order to handle inappropriately slow response times
+  As a developer
+  I want my request to raise an exception after my specified read_timeout as elapsed
+
+  Scenario: A long running response
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/long_running_service.html'
+    And that service takes 2 seconds to generate a response
+    When I set my HTTParty read_timeout option to 1
+    And I call HTTParty#get with '/long_running_service.html'
+    Then it should raise a Timeout::Error exception
+    And I wait for the server to recover

data/httparty.gemspec

@@ -1,24 +1,27 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
 require "httparty/version"
 
 Gem::Specification.new do |s|
   s.name        = "httparty"
   s.version     = HTTParty::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.licenses    = ['MIT']
   s.authors     = ["John Nunemaker", "Sandro Turriate"]
   s.email       = ["nunemaker@gmail.com"]
   s.homepage    = "http://jnunemaker.github.com/httparty"
-  s.summary     = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
-  s.description = %q{Makes http fun! Also, makes consuming restful web services dead easy.}
+  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.add_dependency 'multi_json', "~> 1.0"
-  s.add_dependency 'multi_xml'
+  s.required_ruby_version     = '>= 1.9.3'
 
+  s.add_dependency 'multi_xml', ">= 0.5.2"
+
+  # 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")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 end

data/lib/httparty/connection_adapter.rb

@@ -38,18 +38,26 @@ 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.
-  # Something are probably interesting are as follows:
+  # Some things that are probably interesting are as follows:
   # * :+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
   # * :+debug_output+: see HTTParty::ClassMethods.debug_output.
   # * :+pem+: contains pem data. see HTTParty::ClassMethods.pem.
+  # * :+verify+: verify the server’s certificate against the ca certificate.
+  # * :+verify_peer+: set to false to turn off server verification but still send client certificate
   # * :+ssl_ca_file+: see HTTParty::ClassMethods.ssl_ca_file.
   # * :+ssl_ca_path+: see HTTParty::ClassMethods.ssl_ca_path.
-  # * :+connection_adapter_options+: contains the hash your passed to HTTParty.connection_adapter when you configured your connection adapter
+  # * :+connection_adapter_options+: contains the hash you passed to HTTParty.connection_adapter when you configured your connection adapter
   class ConnectionAdapter
-
     # Private: Regex used to strip brackets from IPv6 URIs.
     StripIpv6BracketsRegex = /\A\[(.*)\]\z/
 
+    OPTION_DEFAULTS = {
+      verify: true,
+      verify_peer: true
+    }
+
     # Public
     def self.call(uri, options)
       new(uri, options).connection
@@ -57,16 +65,22 @@ module HTTParty
 
     attr_reader :uri, :options
 
-    def initialize(uri, options={})
-      raise ArgumentError, "uri must be a URI, not a #{uri.class}" unless uri.kind_of? URI
+    def initialize(uri, options = {})
+      uri_adapter = options[:uri_adapter] || URI
+      raise ArgumentError, "uri must be a #{uri_adapter}, not a #{uri.class}" unless uri.is_a? uri_adapter
 
       @uri = uri
-      @options = options
+      @options = OPTION_DEFAULTS.merge(options)
     end
 
     def connection
       host = clean_host(uri.host)
-      http = Net::HTTP.new(host, uri.port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
+      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])
+      else
+        http = Net::HTTP.new(host, port)
+      end
 
       http.use_ssl = ssl_implied?(uri)
 
@@ -77,6 +91,14 @@ module HTTParty
         http.read_timeout = options[:timeout]
       end
 
+      if options[:read_timeout] && (options[:read_timeout].is_a?(Integer) || options[:read_timeout].is_a?(Float))
+        http.read_timeout = options[:read_timeout]
+      end
+
+      if options[:open_timeout] && (options[:open_timeout].is_a?(Integer) || options[:open_timeout].is_a?(Float))
+        http.open_timeout = options[:open_timeout]
+      end
+
       if options[:debug_output]
         http.set_debug_output(options[:debug_output])
       end
@@ -85,7 +107,26 @@ module HTTParty
         http.ciphers = options[:ciphers]
       end
 
-      return http
+      # Bind to a specific local address or port
+      #
+      # @see https://bugs.ruby-lang.org/issues/6617
+      if options[:local_host]
+        if RUBY_VERSION >= "2.0.0"
+          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"
+          http.local_port = options[:local_port]
+        else
+          Kernel.warn("Warning: option :local_port requires Ruby version 2.0 or later")
+        end
+      end
+
+      http
     end
 
     private
@@ -99,18 +140,42 @@ module HTTParty
     end
 
     def ssl_implied?(uri)
-      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+      uri.port == 443 || uri.scheme == 'https'
+    end
+
+    def verify_ssl_certificate?
+      !(options[:verify] == false || options[:verify_peer] == false)
     end
 
     def attach_ssl_certificates(http, options)
       if http.use_ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        if options.fetch(:verify, true)
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          if options[:cert_store]
+            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
+          end
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
 
         # Client certificate authentication
+        # 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.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.verify_mode = verify_ssl_certificate? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        end
+
+        # PKCS12 client certificate authentication
+        if options[:p12]
+          p12 = OpenSSL::PKCS12.new(options[:p12], options[:p12_password])
+          http.cert = p12.certificate
+          http.key = p12.key
+          http.verify_mode = verify_ssl_certificate? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
         end
 
         # SSL certificate authority file and/or directory

data/lib/httparty/cookie_hash.rb

@@ -1,6 +1,5 @@
 class HTTParty::CookieHash < Hash #:nodoc:
-
-  CLIENT_COOKIES = %w{path expires domain path secure HTTPOnly}
+  CLIENT_COOKIES = %w(path expires domain path secure httponly)
 
   def add_cookies(value)
     case value
@@ -8,7 +7,7 @@ class HTTParty::CookieHash < Hash #:nodoc:
       merge!(value)
     when String
       value.split('; ').each do |cookie|
-        array = cookie.split('=')
+        array = cookie.split('=', 2)
         self[array[0].to_sym] = array[1]
       end
     else
@@ -17,6 +16,6 @@ class HTTParty::CookieHash < Hash #:nodoc:
   end
 
   def to_cookie_string
-    delete_if { |k, v| CLIENT_COOKIES.include?(k.to_s) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
+    reject { |k, v| CLIENT_COOKIES.include?(k.to_s.downcase) }.collect { |k, v| "#{k}=#{v}" }.join("; ")
   end
 end

data/lib/httparty/exceptions.rb

@@ -1,13 +1,16 @@
 module HTTParty
-  # Exception raised when you attempt to set a non-existant format
-  class UnsupportedFormat < StandardError; end
+  # @abstact Exceptions raised by HTTParty inherit from Error
+  class Error < StandardError; end
+
+  # Exception raised when you attempt to set a non-existent format
+  class UnsupportedFormat < Error; end
 
   # Exception raised when using a URI scheme other than HTTP or HTTPS
-  class UnsupportedURIScheme < StandardError; end
+  class UnsupportedURIScheme < Error; end
 
   # @abstract Exceptions which inherit from ResponseError contain the Net::HTTP
   # response object accessible via the {#response} method.
-  class ResponseError < StandardError
+  class ResponseError < Error
     # Returns the response of the last request
     # @return [Net::HTTPResponse] A subclass of Net::HTTPResponse, e.g.
     # Net::HTTPOK
@@ -23,4 +26,7 @@ module HTTParty
   # Exception that is raised when request has redirected too many times.
   # Calling {#response} returns the Net:HTTP response object.
   class RedirectionTooDeep < ResponseError; end
+
+  # Exception that is raised when request redirects and location header is present more than once
+  class DuplicateLocationHeader < ResponseError; end
 end

data/lib/httparty/hash_conversions.rb

@@ -3,18 +3,16 @@ module HTTParty
     # @return <String> This hash as a query string
     #
     # @example
-    #   { :name => "Bob",
-    #     :address => {
-    #       :street => '111 Ruby Ave.',
-    #       :city => 'Ruby Central',
-    #       :phones => ['111-111-1111', '222-222-2222']
+    #   { name: "Bob",
+    #     address: {
+    #       street: '111 Ruby Ave.',
+    #       city: 'Ruby Central',
+    #       phones: ['111-111-1111', '222-222-2222']
     #     }
     #   }.to_params
     #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
     def self.to_params(hash)
-      params = hash.map { |k,v| normalize_param(k,v) }.join
-      params.chop! # trailing &
-      params
+      hash.to_hash.map { |k, v| normalize_param(k, v) }.join.chop
     end
 
     # @param key<Object> The key for the param.
@@ -27,20 +25,24 @@ module HTTParty
       param = ''
       stack = []
 
-      if value.is_a?(Array)
-        param << value.map { |element| normalize_param("#{key}[]", element) }.join
-      elsif value.is_a?(Hash)
-        stack << [key,value]
+      if value.respond_to?(:to_ary)
+        param << if value.empty?
+                   "#{key}[]=&"
+                 else
+                   value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
+                 end
+      elsif value.respond_to?(:to_hash)
+        stack << [key, value.to_hash]
       else
-        param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
+        param << "#{key}=#{ERB::Util.url_encode(value.to_s)}&"
       end
 
       stack.each do |parent, hash|
-        hash.each do |key, value|
-          if value.is_a?(Hash)
-            stack << ["#{parent}[#{key}]", value]
+        hash.each do |k, v|
+          if v.respond_to?(:to_hash)
+            stack << ["#{parent}[#{k}]", v.to_hash]
           else
-            param << normalize_param("#{parent}[#{key}]", value)
+            param << normalize_param("#{parent}[#{k}]", v)
           end
         end
       end