httparty 0.13.1 → 0.13.2

data/examples/whoismyrep.rb

@@ -7,4 +7,4 @@ class Rep
 end
 
 pp Rep.get('http://whoismyrepresentative.com/getall_mems.php?zip=46544')
-pp Rep.get('http://whoismyrepresentative.com/getall_mems.php', :query => {:zip => 46544})
+pp Rep.get('http://whoismyrepresentative.com/getall_mems.php', query: {zip: 46544})

data/features/steps/httparty_steps.rb

@@ -30,7 +30,7 @@ When /I call HTTParty#get with '(.*)' and a basic_auth hash:/ do |url, auth_tabl
   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
 
@@ -38,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

data/httparty.gemspec

@@ -6,6 +6,7 @@ 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"
@@ -17,6 +18,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'json',      "~> 1.8"
   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")

data/lib/httparty.rb

@@ -41,13 +41,13 @@ module HTTParty
   # == Common Request Options
   # Request methods (get, post, patch, put, delete, head, options) all take a common set of options. These are:
   #
-  # [:+body+:] Body of the request. If passed a Hash, will try to normalize it first, by default passing it to ActiveSupport::to_params. Any other kind of object will get used as-is.
+  # [:+body+:] Body of the request. If passed an object that responds to #to_hash, will try to normalize it first, by default passing it to ActiveSupport::to_params. Any other kind of object will get used as-is.
   # [:+http_proxyaddr+:] Address of proxy server to use.
   # [:+http_proxyport+:]  Port of proxy server to use.
   # [:+http_proxyuser+:] User for proxy server authentication.
   # [:+http_proxypass+:] Password for proxy server authentication.
   # [:+limit+:] Maximum number of redirects to follow. Takes precedences over :+no_follow+.
-  # [:+query+:] Query string, or a Hash representing it. Normalized according to the same rules as :+body+. If you specify this on a POST, you must use a Hash. See also HTTParty::ClassMethods.default_params.
+  # [:+query+:] Query string, or an object that responds to #to_hash representing it. Normalized according to the same rules as :+body+. If you specify this on a POST, you must use an object which responds to #to_hash. See also HTTParty::ClassMethods.default_params.
   # [:+timeout+:] Timeout for opening connection and reading data.
   # [:+local_host:] Local address to bind to before connecting.
   # [:+local_port:] Local port to bind to before connecting.
@@ -58,7 +58,7 @@ module HTTParty
   # * :+debug_output+: see HTTParty::ClassMethods.debug_output.
   # * :+digest_auth+: see HTTParty::ClassMethods.digest_auth. Only one of :+basic_auth+ and :+digest_auth+ can be used at a time; if you try using both, you'll get an ArgumentError.
   # * :+format+: see HTTParty::ClassMethods.format.
-  # * :+headers+: see HTTParty::ClassMethods.headers. Must be a Hash.
+  # * :+headers+: see HTTParty::ClassMethods.headers. Must be a an object which responds to #to_hash.
   # * :+maintain_method_across_redirects+: see HTTParty::ClassMethods.maintain_method_across_redirects.
   # * :+no_follow+: see HTTParty::ClassMethods.no_follow.
   # * :+parser+: see HTTParty::ClassMethods.parser.
@@ -116,7 +116,7 @@ module HTTParty
     #     basic_auth 'username', 'password'
     #   end
     def basic_auth(u, p)
-      default_options[:basic_auth] = {:username => u, :password => p}
+      default_options[:basic_auth] = {username: u, password: p}
     end
 
     # Allows setting digest authentication username and password.
@@ -126,14 +126,14 @@ module HTTParty
     #     digest_auth 'username', 'password'
     #   end
     def digest_auth(u, p)
-      default_options[:digest_auth] = {:username => u, :password => p}
+      default_options[:digest_auth] = {username: u, password: p}
     end
 
     # Do not send rails style query strings.
     # Specically, don't use bracket notation when sending an array
     #
     # For a query:
-    #   get '/', :query => {:selected_ids => [1,2,3]}
+    #   get '/', query: {selected_ids: [1,2,3]}
     #
     # The default query string looks like this:
     #   /?selected_ids[]=1&selected_ids[]=2&selected_ids[]=3
@@ -156,10 +156,10 @@ module HTTParty
     #
     #   class Foo
     #     include HTTParty
-    #     default_params :api_key => 'secret', :another => 'foo'
+    #     default_params api_key: 'secret', another: 'foo'
     #   end
     def default_params(h={})
-      raise ArgumentError, 'Default params must be a hash' unless h.is_a?(Hash)
+      raise ArgumentError, 'Default params must an object which respond to #to_hash' unless h.respond_to?(:to_hash)
       default_options[:default_params] ||= {}
       default_options[:default_params].merge!(h)
     end
@@ -216,13 +216,13 @@ module HTTParty
     #     headers 'Accept' => 'text/html'
     #   end
     def headers(h={})
-      raise ArgumentError, 'Headers must be a hash' unless h.is_a?(Hash)
+      raise ArgumentError, 'Headers must an object which responds to #to_hash' unless h.respond_to?(:to_hash)
       default_options[:headers] ||= {}
-      default_options[:headers].merge!(h)
+      default_options[:headers].merge!(h.to_hash)
     end
 
     def cookies(h={})
-      raise ArgumentError, 'Cookies must be a hash' unless h.is_a?(Hash)
+      raise ArgumentError, 'Cookies must an object which respond to #to_hash' unless h.respond_to?(:to_hash)
       default_cookies.add_cookies(h)
     end
 
@@ -294,6 +294,24 @@ module HTTParty
       default_options[:maintain_method_across_redirects] = value
     end
 
+    # Declare that you wish to resend the full HTTP request across redirects,
+    # even on redirects that should logically become GET requests.
+    # A 303 redirect in HTTP signifies that the redirected url should normally
+    # retrieved using a GET request, for instance, it is the output of a previous
+    # POST. maintain_method_across_redirects respects this behavior, but you
+    # can force HTTParty to resend_on_redirect even on 303 responses.
+    #
+    # @example
+    #   class Foo
+    #     include HTTParty
+    #     base_uri 'http://google.com'
+    #     resend_on_redirect
+    #   end
+
+    def resend_on_redirect(value = true)
+      default_options[:resend_on_redirect] = value
+    end
+
     # Allows setting a PEM file to be used
     #
     #   class Foo
@@ -320,7 +338,7 @@ module HTTParty
     # Helpful for overriding the default rails normalization of Array queries.
     #
     # For a query:
-    #   get '/', :query => {:selected_ids => [1,2,3]}
+    #   get '/', query: {selected_ids: [1,2,3]}
     #
     # The default query string normalizer returns:
     #   /?selected_ids[]=1&selected_ids[]=2&selected_ids[]=3
@@ -428,7 +446,7 @@ module HTTParty
     # @example provide optional configuration for your connection_adapter
     #   class Foo
     #     include HTTParty
-    #     connection_adapter Proc.new {|uri, options| ... }, {:foo => :bar}
+    #     connection_adapter Proc.new {|uri, options| ... }, {foo: :bar}
     #   end
     #
     # @see HTTParty::ConnectionAdapter
@@ -452,7 +470,7 @@ module HTTParty
     #
     #   # Simple get with full url and query parameters
     #   # ie: http://foo.com/resource.json?limit=10
-    #   Foo.get('http://foo.com/resource.json', :query => {:limit => 10})
+    #   Foo.get('http://foo.com/resource.json', query: {limit: 10})
     def get(path, options={}, &block)
       perform_request Net::HTTP::Get, path, options, &block
     end
@@ -464,11 +482,11 @@ module HTTParty
     #   end
     #
     #   # Simple post with full url and setting the body
-    #   Foo.post('http://foo.com/resources', :body => {:bar => 'baz'})
+    #   Foo.post('http://foo.com/resources', body: {bar: 'baz'})
     #
     #   # Simple post with full url using :query option,
     #   # which gets set as form data on the request.
-    #   Foo.post('http://foo.com/resources', :query => {:bar => 'baz'})
+    #   Foo.post('http://foo.com/resources', query: {bar: 'baz'})
     def post(path, options={}, &block)
       perform_request Net::HTTP::Post, path, options, &block
     end
@@ -515,7 +533,7 @@ module HTTParty
     private
 
       def perform_request(http_method, path, options, &block) #:nodoc:
-        options = default_options.merge(options)
+        options = ModuleInheritableAttributes.hash_deep_dup(default_options).merge(options)
         process_headers(options)
         process_cookies(options)
         Request.new(http_method, path, options).perform(&block)

data/lib/httparty/connection_adapter.rb

@@ -45,6 +45,7 @@ module HTTParty
   # * :+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 you passed to HTTParty.connection_adapter when you configured your connection adapter
@@ -152,10 +153,11 @@ module HTTParty
         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 = options[:verify_peer] == false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
         end
 
         # PKCS12 client certificate authentication
@@ -163,7 +165,7 @@ module HTTParty
           p12 = OpenSSL::PKCS12.new(options[:p12], options[:p12_password])
           http.cert = p12.certificate
           http.key = p12.key
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.verify_mode = options[:verify_peer] == false ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
         end
 
         # SSL certificate authority file and/or directory

data/lib/httparty/cookie_hash.rb

@@ -1,6 +1,6 @@
 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

data/lib/httparty/hash_conversions.rb

@@ -3,16 +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 = hash.to_hash.map { |k,v| normalize_param(k,v) }.join
       params.chop! # trailing &
       params
     end
@@ -27,18 +27,18 @@ 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 << value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
+      elsif value.respond_to?(:to_hash)
+        stack << [key,value.to_hash]
       else
         param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
       end
 
       stack.each do |parent, hash|
         hash.each do |k, v|
-          if v.is_a?(Hash)
-            stack << ["#{parent}[#{k}]", v]
+          if v.respond_to?(:to_hash)
+            stack << ["#{parent}[#{k}]", v.to_hash]
           else
             param << normalize_param("#{parent}[#{k}]", v)
           end

data/lib/httparty/logger/apache_logger.rb

@@ -14,7 +14,7 @@ module HTTParty
         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['Content-Length']
+        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 || "-"} "
       end
     end

data/lib/httparty/logger/logger.rb

@@ -5,7 +5,7 @@ module HTTParty
   module Logger
     def self.build(logger, level, formatter)
       level  ||= :info
-      format ||= :apache
+      formatter ||= :apache
 
       case formatter
       when :curl

data/lib/httparty/net_digest_auth.rb

@@ -44,7 +44,10 @@ module Net
     private
 
       def parse(response_header)
-        response_header['www-authenticate'] =~ /Digest (.*)/
+        header = response_header['www-authenticate']
+          .gsub(/qop=(auth(?:-int)?)/, %Q(qop="\\1"))
+
+        header =~ /Digest (.*)/
         params = {}
         $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
         params

data/lib/httparty/request.rb

@@ -18,8 +18,8 @@ module HTTParty
       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}=#{URI.encode(v.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}"}
         else
           HashConversions.to_params(key => value)
         end
@@ -33,13 +33,14 @@ module HTTParty
       self.http_method = http_method
       self.path = path
       self.options = {
-        :limit => o.delete(:no_follow) ? 1 : 5,
-        :assume_utf16_is_big_endian => true,
-        :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,
+        connection_adapter: ConnectionAdapter
       }.merge(o)
+      set_basic_auth_from_uri
     end
 
     def path=(uri)
@@ -55,6 +56,10 @@ module HTTParty
     end
 
     def uri
+      if redirect && path.relative? && path.path[0] != "/"
+        path.path = @last_uri.path.gsub(/[^\/]+$/, "") + path.path
+      end
+
       new_uri = path.relative? ? URI.parse("#{base_uri}#{path}") : path.clone
 
       # avoid double query string on redirects [#12]
@@ -118,11 +123,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
@@ -149,14 +154,14 @@ module HTTParty
       @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]
-      @raw_request.initialize_http_header(options[:headers])
+      @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]
       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
@@ -168,8 +173,8 @@ 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?
@@ -257,13 +262,21 @@ module HTTParty
         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] and options[:resend_on_redirect]
+            self.http_method = Net::HTTP::Get
+          end
+        else
+          unless options[:maintain_method_across_redirects]
+            self.http_method = Net::HTTP::Get
+          end
+        end
         capture_cookies(last_response)
         perform(&block)
       else
         body = body || last_response.body
         body = encode_body(body)
-        Response.new(self, last_response, lambda { parse_response(body) }, :body => body)
+        Response.new(self, last_response, lambda { parse_response(body) }, body: body)
       end
     end
 
@@ -299,7 +312,7 @@ 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(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
@@ -317,15 +330,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