httparty 0.13.5 → 0.13.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a6b1d5f5b4dfe131cddcf36948fb9102b93f67d
-  data.tar.gz: 10206b7de3285e93f767f7578a77600256892b82
+  metadata.gz: 7ff4fbf77e1502f71829faa6032ec50bce93aae6
+  data.tar.gz: bcd37d969fec45917adec0a7e6ac202308520601
 SHA512:
-  metadata.gz: aa60eff289622231ce78d3ec3edcc1a6945deb42ede5ba814534117f57b768bcbcb64c2baae1bc1abe3918c15f9af3bc175789a6d63d940357630aed60809255
-  data.tar.gz: 8e4240d4b726486e591c2dc33943aba90aafbc9bb26ba79417e0ce8481b30f97b34df171619b16229cd895565bbc180666cc5481597705a5a401ebef08c6ee81
+  metadata.gz: 0edda1d12877f8dbec768ef37934ad0853c7383dfbb1d0f1051de314b469dfe9eed8da318ea5cea3112c39d2dbe7edec5b00785834bfdf77ba75877a2163002a
+  data.tar.gz: a97e1c55e863564388944cb4acf5ae2a49942a4df79dc09834025e7346929e9bd5a40b1e29d3f3cbdff479a4318ce1f100203da3f90b6b29085c433f2898bb0d

data/CONTRIBUTING.md

@@ -0,0 +1,23 @@
+# Contributing
+
+* Contributions will not be accepted without tests.
+* Please post unconfirmed bugs to the mailing list first: https://groups.google.com/forum/#!forum/httparty-gem
+* Don't change the version. The maintainers will handle that when they release.
+* Always provide as much information and reproducibility as possible when filing an issue or submitting a pull request.
+
+## Workflow
+
+* Fork the project.
+* Run `bundle`
+* Run `bundle exec rake`
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Run `bundle exec rake` (No, REALLY :))
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Help and Docs
+
+* https://groups.google.com/forum/#!forum/httparty-gem
+* http://stackoverflow.com/questions/tagged/httparty
+* http://rdoc.info/projects/jnunemaker/httparty

data/History

@@ -1,3 +1,20 @@
+== 0.13.6
+* avoid calling String#strip on invalid Strings
+* preserve request method on 307 and 308 redirects
+* output version with --version for command line bin
+* maintain head request method across redirects by default
+* add support for RFC2617 MD5-sess algorithm type
+* add party popper emoji to post install message
+
+== 0.13.5
+* allow setting a custom URI adapter
+
+== 0.13.4
+* correct redirect url for redirect paths without leading slash
+* remove core_extensions.rb as backwards compat for ruby 1.8 not needed
+* replace URI.encode with ERB::Util.url_encode
+* allow the response to be tapped
+
 == 0.13.3
 * minor improvement
   * added option to allow for streaming large files without loading them into memory (672cdae)

data/README.md

@@ -18,7 +18,7 @@ gem install httparty
 
 ```ruby
 # Use the class methods to get down to business quickly
-response = HTTParty.get('https://api.stackexchange.com/2.2/questions?site=stackoverflow')
+response = HTTParty.get('http://api.stackexchange.com/2.2/questions?site=stackoverflow')
 
 puts response.body, response.code, response.message, response.headers.inspect
 

data/bin/httparty

@@ -62,6 +62,11 @@ OptionParser.new do |o|
     puts o
     exit
   end
+
+  o.on("--version", "Show HTTParty version") do |ver|
+    puts "Version: #{HTTParty::VERSION}"
+    exit
+  end
 end.parse!
 
 if ARGV.empty?

data/features/command_line.feature

@@ -9,6 +9,11 @@ Feature: Command Line
     When I run `httparty --help`
     Then the output should contain "-f, --format [FORMAT]"
 
+  Scenario: Show current version
+    When I run `httparty --version`
+    Then the output should contain "Version:"
+    And the output should not contain "You need to provide a URL"
+
   Scenario: Make a get request
     Given a remote deflate service on port '4001'
     And the response from the service has a body of 'GET request'
@@ -87,4 +92,4 @@ Feature: Command Line
     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 run `httparty http://0.0.0.0:4010/service.csv --format csv`
-    Then the output should contain '["Last Name", "Name"]'
+    Then the output should contain '["Last Name", "Name"]'

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/steps/mongrel_helper.rb

@@ -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

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

data/httparty.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |s|
   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.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")

data/lib/httparty.rb

@@ -39,6 +39,8 @@ module HTTParty
   # [:+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.
+  # [:+body_steam:] Allow streaming to a REST server to specify a body_stream.
+  # [:+stream_body:] Allow for streaming large files without loading them into memory.
   #
   # There are also another set of options with names corresponding to various class methods. The methods in question are those that let you set a class-wide default, and the options override the defaults on a request-by-request basis. Those options are:
   # * :+base_uri+: see HTTParty::ClassMethods.base_uri.
@@ -50,6 +52,7 @@ module HTTParty
   # * :+maintain_method_across_redirects+: see HTTParty::ClassMethods.maintain_method_across_redirects.
   # * :+no_follow+: see HTTParty::ClassMethods.no_follow.
   # * :+parser+: see HTTParty::ClassMethods.parser.
+  # * :+uri_adapter+: see HTTParty::ClassMethods.uri_adapter
   # * :+connection_adapter+: see HTTParty::ClassMethods.connection_adapter.
   # * :+pem+: see HTTParty::ClassMethods.pem.
   # * :+query_string_normalizer+: see HTTParty::ClassMethods.query_string_normalizer
@@ -265,7 +268,9 @@ module HTTParty
     end
 
     # Declare that you wish to maintain the chosen HTTP method across redirects.
-    # The default behavior is to follow redirects via the GET method.
+    # The default behavior is to follow redirects via the GET method, except
+    # if you are making a HEAD request, in which case the default is to
+    # follow all redirects with HEAD requests.
     # If you wish to maintain the original method, you can set this option to true.
     #
     # @example
@@ -420,6 +425,17 @@ module HTTParty
       end
     end
 
+    # Allows setting a custom URI adapter.
+    #
+    #   class Foo
+    #     include HTTParty
+    #     uri_adapter Addressable::URI
+    #   end
+    def uri_adapter(uri_adapter)
+      raise ArgumentError, 'The URI adapter should respond to #parse' unless uri_adapter.respond_to?(:parse)
+      default_options[:uri_adapter] = uri_adapter
+    end
+
     # Allows setting a custom connection_adapter for the http connections
     #
     # @example
@@ -503,6 +519,7 @@ module HTTParty
 
     # Perform a HEAD request to a path
     def head(path, options = {}, &block)
+      ensure_method_maintained_across_redirects options
       perform_request Net::HTTP::Head, path, options, &block
     end
 
@@ -515,6 +532,12 @@ module HTTParty
 
     private
 
+    def ensure_method_maintained_across_redirects(options)
+      unless options.has_key? :maintain_method_across_redirects
+        options[:maintain_method_across_redirects] = true
+      end
+    end
+
     def perform_request(http_method, path, options, &block) #:nodoc:
       options = ModuleInheritableAttributes.hash_deep_dup(default_options).merge(options)
       process_headers(options)

data/lib/httparty/connection_adapter.rb

@@ -61,7 +61,8 @@ module HTTParty
     attr_reader :uri, :options
 
     def initialize(uri, options = {})
-      raise ArgumentError, "uri must be a URI, not a #{uri.class}" unless uri.is_a? URI
+      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
@@ -69,10 +70,11 @@ module HTTParty
 
     def connection
       host = clean_host(uri.host)
+      port = uri.port || (uri.scheme == 'https' ? 443 : 80)
       if options[:http_proxyaddr]
-        http = Net::HTTP.new(host, uri.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, uri.port)
+        http = Net::HTTP.new(host, port)
       end
 
       http.use_ssl = ssl_implied?(uri)
@@ -133,7 +135,7 @@ module HTTParty
     end
 
     def ssl_implied?(uri)
-      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+      uri.port == 443 || uri.scheme == 'https'
     end
 
     def attach_ssl_certificates(http, options)

data/lib/httparty/logger/{apache_logger.rb → apache_formatter.rb}

@@ -1,6 +1,6 @@
 module HTTParty
   module Logger
-    class ApacheLogger #:nodoc:
+    class ApacheFormatter #:nodoc:
       TAG_NAME = HTTParty.name
 
       attr_accessor :level, :logger, :current_time

data/lib/httparty/logger/{curl_logger.rb → curl_formatter.rb}

@@ -1,6 +1,6 @@
 module HTTParty
   module Logger
-    class CurlLogger #:nodoc:
+    class CurlFormatter #:nodoc:
       TAG_NAME = HTTParty.name
       OUT = ">"
       IN = "<"

data/lib/httparty/logger/logger.rb

@@ -1,18 +1,26 @@
-require 'httparty/logger/apache_logger'
-require 'httparty/logger/curl_logger'
+require 'httparty/logger/apache_formatter'
+require 'httparty/logger/curl_formatter'
 
 module HTTParty
   module Logger
+    def self.formatters
+      @formatters ||= {
+        :curl => Logger::CurlFormatter,
+        :apache => Logger::ApacheFormatter
+      }
+    end
+
+    def self.add_formatter(name, formatter)
+      raise HTTParty::Error.new("Log Formatter with name #{name} already exists") if formatters.include?(name)
+      formatters.merge!(name.to_sym => formatter)
+    end
+
     def self.build(logger, level, formatter)
       level ||= :info
       formatter ||= :apache
 
-      case formatter
-      when :curl
-        Logger::CurlLogger.new(logger, level)
-      else
-        Logger::ApacheLogger.new(logger, level)
-      end
+      logger_klass = formatters[formatter] || Logger::ApacheFormatter
+      logger_klass.new(logger, level)
     end
   end
 end

data/lib/httparty/net_digest_auth.rb

@@ -41,6 +41,8 @@ module Net
           %(response="#{request_digest}")
         ]
 
+        header << %(algorithm="#{@response['algorithm']}") if algorithm_present?
+
         if qop_present?
           fields = [
             %(cnonce="#{@cnonce}"),
@@ -66,7 +68,8 @@ module Net
 
         header =~ /Digest (.*)/
         params = {}
-        $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        non_quoted = $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        non_quoted.gsub(/(\w+)=([^,]*)/) { params[$1] = $2 }
         params
       end
 
@@ -105,8 +108,21 @@ module Net
         Digest::MD5.hexdigest(str)
       end
 
+      def algorithm_present?
+        @response.key?('algorithm') && !@response['algorithm'].empty?
+      end
+      
+      def use_md5_sess?
+        algorithm_present? && @response['algorithm'] == 'MD5-sess'
+      end
+      
       def a1
-        [@username, @response['realm'], @password].join(":")
+        a1_user_realm_pwd =  [@username, @response['realm'], @password].join(':')
+        if use_md5_sess?
+          [ md5(a1_user_realm_pwd), @response['nonce'], @cnonce ].join(':')
+        else
+          a1_user_realm_pwd
+        end
       end
 
       def a2

data/lib/httparty/parser.rb

@@ -98,7 +98,9 @@ module HTTParty
     # @return [Object] the parsed body
     # @return [nil] when the response body is nil, an empty string, spaces only or "null"
     def parse
-      return nil if body.nil? || body.strip.empty? || body == "null"
+      return nil if body.nil?
+      return nil if body == "null"
+      return nil if body.valid_encoding? && body.strip.empty?
       if supports_format?
         parse_supported_format
       else
@@ -113,7 +115,7 @@ module HTTParty
     end
 
     def json
-      JSON.load(body, nil)
+      JSON.parse(body, :quirks_mode => true, :allow_nan => true)
     end
 
     def csv

data/lib/httparty/request.rb

@@ -12,7 +12,7 @@ module HTTParty
       Net::HTTP::Copy
     ]
 
-    SupportedURISchemes  = [URI::HTTP, URI::HTTPS, URI::Generic]
+    SupportedURISchemes  = ['http', 'https', 'webcal', nil]
 
     NON_RAILS_QUERY_STRING_NORMALIZER = proc do |query|
       Array(query).sort_by { |a| a[0].to_s }.map do |key, value|
@@ -31,20 +31,30 @@ module HTTParty
 
     def initialize(http_method, path, o = {})
       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,
+        uri_adapter: URI,
         connection_adapter: ConnectionAdapter
       }.merge(o)
+      self.path = path
       set_basic_auth_from_uri
     end
 
     def path=(uri)
-      @path = URI(uri)
+      uri_adapter = options[:uri_adapter]
+
+      @path = if uri.is_a?(uri_adapter)
+        uri
+      elsif String.try_convert(uri)
+        uri_adapter.parse uri
+      else
+        raise ArgumentError,
+          "bad argument (expected #{uri_adapter} object or URI string)"
+      end
     end
 
     def request_uri(uri)
@@ -63,14 +73,14 @@ module HTTParty
         path.path = last_uri_host + path.path
       end
 
-      new_uri = path.relative? ? URI.parse("#{base_uri}#{path}") : path.clone
+      new_uri = path.relative? ? options[:uri_adapter].parse("#{base_uri}#{path}") : path.clone
 
       # avoid double query string on redirects [#12]
       unless redirect
         new_uri.query = query_string(new_uri)
       end
 
-      unless SupportedURISchemes.include? new_uri.class
+      unless SupportedURISchemes.include? new_uri.scheme
         raise UnsupportedURIScheme, "'#{new_uri}' Must be HTTP, HTTPS or Generic"
       end
 
@@ -78,7 +88,13 @@ module HTTParty
     end
 
     def base_uri
-      redirect ? "#{@last_uri.scheme}://#{@last_uri.host}" : options[:base_uri]
+      if redirect
+        base_uri = "#{@last_uri.scheme}://#{@last_uri.host}"
+        base_uri += ":#{@last_uri.port}" if @last_uri.port != 80
+        base_uri
+      else
+        options[:base_uri]
+      end
     end
 
     def format
@@ -266,7 +282,7 @@ module HTTParty
           unless options[:maintain_method_across_redirects] && options[:resend_on_redirect]
             self.http_method = Net::HTTP::Get
           end
-        else
+        elsif last_response.code != '307' && last_response.code != '308'
           unless options[:maintain_method_across_redirects]
             self.http_method = Net::HTTP::Get
           end
@@ -295,12 +311,9 @@ module HTTParty
 
     def response_redirects?
       case last_response
-      when Net::HTTPMultipleChoice, # 300
-           Net::HTTPMovedPermanently, # 301
-           Net::HTTPFound, # 302
-           Net::HTTPSeeOther, # 303
-           Net::HTTPUseProxy, # 305
-           Net::HTTPTemporaryRedirect
+      when Net::HTTPNotModified # 304
+        false
+      when Net::HTTPRedirection
         options[:follow_redirects] && last_response.key?('location')
       end
     end

data/lib/httparty/version.rb

@@ -1,3 +1,3 @@
 module HTTParty
-  VERSION = "0.13.5"
+  VERSION = "0.13.6"
 end

data/spec/httparty/connection_adapter_spec.rb

@@ -449,6 +449,20 @@ RSpec.describe HTTParty::ConnectionAdapter do
           end
         end
       end
+
+      context "when uri port is not defined" do
+        context "falls back to 80 port on http" do
+          let(:uri) { URI 'http://foobar.com' }
+          before { allow(uri).to receive(:port).and_return(nil) }
+          it { expect(subject.port).to be 80 }
+        end
+
+        context "falls back to 443 port on https" do
+          let(:uri) { URI 'https://foobar.com' }
+          before { allow(uri).to receive(:port).and_return(nil) }
+          it { expect(subject.port).to be 443 }
+        end
+      end
     end
   end
 end

data/spec/httparty/logger/{apache_logger_spec.rb → apache_formatter_spec.rb}

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
 
-RSpec.describe HTTParty::Logger::ApacheLogger do
+RSpec.describe HTTParty::Logger::ApacheFormatter do
   let(:subject) { described_class.new(logger_double, :info) }
   let(:logger_double) { double('Logger') }
   let(:request_double) { double('Request', http_method: Net::HTTP::Get, path: "http://my.domain.com/my_path") }

data/spec/httparty/logger/{curl_logger_spec.rb → curl_formatter_spec.rb}

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
 
-RSpec.describe HTTParty::Logger::CurlLogger do
+RSpec.describe HTTParty::Logger::CurlFormatter do
   describe "#format" do
     it "formats a response in a style that resembles a -v curl" do
       logger_double = double

data/spec/httparty/logger/logger_spec.rb

@@ -11,12 +11,28 @@ RSpec.describe HTTParty::Logger do
 
     it "defaults format to :apache" do
       logger_double = double
-      expect(subject.build(logger_double, nil, nil)).to be_an_instance_of(HTTParty::Logger::ApacheLogger)
+      expect(subject.build(logger_double, nil, nil)).to be_an_instance_of(HTTParty::Logger::ApacheFormatter)
     end
 
     it "builds :curl style logger" do
       logger_double = double
-      expect(subject.build(logger_double, nil, :curl)).to be_an_instance_of(HTTParty::Logger::CurlLogger)
+      expect(subject.build(logger_double, nil, :curl)).to be_an_instance_of(HTTParty::Logger::CurlFormatter)
+    end
+
+    it "builds :custom style logger" do
+      CustomFormatter = Class.new(HTTParty::Logger::CurlFormatter)
+      HTTParty::Logger.add_formatter(:custom, CustomFormatter)
+
+      logger_double = double
+      expect(subject.build(logger_double, nil, :custom)).
+        to be_an_instance_of(CustomFormatter)
+    end
+    it "raises error when formatter exists" do
+      CustomFormatter2= Class.new(HTTParty::Logger::CurlFormatter)
+      HTTParty::Logger.add_formatter(:custom2, CustomFormatter2)
+
+      expect{ HTTParty::Logger.add_formatter(:custom2, CustomFormatter2) }.
+        to raise_error HTTParty::Error
     end
   end
 end

data/spec/httparty/net_digest_auth_spec.rb

@@ -188,4 +188,43 @@ RSpec.describe Net::HTTPHeader::DigestAuthenticator do
       expect(authorization_header).to include(%(response="#{request_digest}"))
     end
   end
+  
+  context "with algorithm specified" do
+    before do
+      @digest = setup_digest({
+                              'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth", algorithm=MD5'
+                             })
+    end
+    
+    it "should recognise algorithm was specified" do
+      expect( @digest.send :algorithm_present? ).to be(true)
+    end
+    
+    it "should set the algorithm header" do
+      expect(authorization_header).to include('algorithm="MD5"')
+    end
+  end
+
+  context "with md5-sess algorithm specified" do
+    before do
+      @digest = setup_digest({
+                              'www-authenticate' => 'Digest realm="myhost@testrealm.com", nonce="NONCE", qop="auth", algorithm=MD5-sess'
+                             })
+    end
+    
+    it "should recognise algorithm was specified" do
+      expect( @digest.send :algorithm_present? ).to be(true)
+    end
+    
+    it "should set the algorithm header" do
+      expect(authorization_header).to include('algorithm="MD5-sess"')
+    end
+    
+    it "should set response using md5-sess algorithm" do
+      request_digest = "md5(md5(md5(Mufasa:myhost@testrealm.com:Circle Of Life):NONCE:md5(deadbeef)):NONCE:00000001:md5(deadbeef):auth:md5(GET:/dir/index.html))"
+      expect(authorization_header).to include(%(response="#{request_digest}"))
+    end
+    
+  end
+  
 end

data/spec/httparty/parser_spec.rb

@@ -97,6 +97,12 @@ RSpec.describe HTTParty::Parser do
       allow(@parser).to receive_messages(body: "   ")
       expect(@parser.parse).to be_nil
     end
+
+    it "does not raise exceptions for bodies with invalid encodings" do
+      allow(@parser).to receive_messages(body: "\x80")
+      allow(@parser).to receive_messages(supports_format?: false)
+      expect(@parser.parse).to_not be_nil
+    end
   end
 
   describe "#supports_format?" do
@@ -147,7 +153,7 @@ RSpec.describe HTTParty::Parser do
     end
 
     it "parses json with JSON" do
-      expect(JSON).to receive(:load).with('body', nil)
+      expect(JSON).to receive(:parse).with('body', :quirks_mode => true, :allow_nan => true)
       subject.send(:json)
     end
 

data/spec/httparty/request_spec.rb

@@ -483,6 +483,14 @@ RSpec.describe HTTParty::Request do
           stub_response '', 300
           expect(HTTParty::Response).to be === @request.perform
         end
+
+        it "redirects including port" do
+          FakeWeb.register_uri(:get, "http://withport.com:3000/v1", status: [301, "Moved Permanently"], location: "http://withport.com:3000/v2")
+          FakeWeb.register_uri(:get, "http://withport.com:3000/v2", status: 200)
+          request = HTTParty::Request.new(Net::HTTP::Get, 'http://withport.com:3000/v1')
+          response = request.perform
+          expect(response.request.base_uri.to_s).to eq("http://withport.com:3000")
+        end
       end
 
       it 'should return a valid object for 4xx response' do
@@ -528,122 +536,124 @@ RSpec.describe HTTParty::Request do
     expect(@request.perform.parsed_response).to eq('Content for you')
   end
 
-  describe "a request that 302 redirects" do
-    before(:each) do
-      @redirect = stub_response("", 302)
-      @redirect['location'] = '/foo'
-
-      @ok = stub_response('<hash><foo>bar</foo></hash>', 200)
-    end
-
-    describe "once" do
+  [300, 301, 302, 305].each do |code|
+    describe "a request that #{code} redirects" do
       before(:each) do
-        allow(@http).to receive(:request).and_return(@redirect, @ok)
-      end
+        @redirect = stub_response("", code)
+        @redirect['location'] = '/foo'
 
-      it "should be handled by GET transparently" do
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        @ok = stub_response('<hash><foo>bar</foo></hash>', 200)
       end
 
-      it "should be handled by POST transparently" do
-        @request.http_method = Net::HTTP::Post
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+      describe "once" do
+        before(:each) do
+          allow(@http).to receive(:request).and_return(@redirect, @ok)
+        end
 
-      it "should be handled by DELETE transparently" do
-        @request.http_method = Net::HTTP::Delete
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by GET transparently" do
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should be handled by MOVE transparently" do
-        @request.http_method = Net::HTTP::Move
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by POST transparently" do
+          @request.http_method = Net::HTTP::Post
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should be handled by COPY transparently" do
-        @request.http_method = Net::HTTP::Copy
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by DELETE transparently" do
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should be handled by PATCH transparently" do
-        @request.http_method = Net::HTTP::Patch
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by MOVE transparently" do
+          @request.http_method = Net::HTTP::Move
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should be handled by PUT transparently" do
-        @request.http_method = Net::HTTP::Put
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by COPY transparently" do
+          @request.http_method = Net::HTTP::Copy
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should be handled by HEAD transparently" do
-        @request.http_method = Net::HTTP::Head
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by PATCH transparently" do
+          @request.http_method = Net::HTTP::Patch
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should be handled by OPTIONS transparently" do
-        @request.http_method = Net::HTTP::Options
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-      end
+        it "should be handled by PUT transparently" do
+          @request.http_method = Net::HTTP::Put
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it "should keep track of cookies between redirects" do
-        @redirect['Set-Cookie'] = 'foo=bar; name=value; HTTPOnly'
-        @request.perform
-        expect(@request.options[:headers]['Cookie']).to match(/foo=bar/)
-        expect(@request.options[:headers]['Cookie']).to match(/name=value/)
-      end
+        it "should be handled by HEAD transparently" do
+          @request.http_method = Net::HTTP::Head
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it 'should update cookies with rediects' do
-        @request.options[:headers] = {'Cookie' => 'foo=bar;'}
-        @redirect['Set-Cookie'] = 'foo=tar;'
-        @request.perform
-        expect(@request.options[:headers]['Cookie']).to match(/foo=tar/)
-      end
+        it "should be handled by OPTIONS transparently" do
+          @request.http_method = Net::HTTP::Options
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
 
-      it 'should keep cookies between rediects' do
-        @request.options[:headers] = {'Cookie' => 'keep=me'}
-        @redirect['Set-Cookie'] = 'foo=tar;'
-        @request.perform
-        expect(@request.options[:headers]['Cookie']).to match(/keep=me/)
-      end
+        it "should keep track of cookies between redirects" do
+          @redirect['Set-Cookie'] = 'foo=bar; name=value; HTTPOnly'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/foo=bar/)
+          expect(@request.options[:headers]['Cookie']).to match(/name=value/)
+        end
 
-      it "should handle multiple Set-Cookie headers between redirects" do
-        @redirect.add_field 'set-cookie', 'foo=bar; name=value; HTTPOnly'
-        @redirect.add_field 'set-cookie', 'one=1; two=2; HTTPOnly'
-        @request.perform
-        expect(@request.options[:headers]['Cookie']).to match(/foo=bar/)
-        expect(@request.options[:headers]['Cookie']).to match(/name=value/)
-        expect(@request.options[:headers]['Cookie']).to match(/one=1/)
-        expect(@request.options[:headers]['Cookie']).to match(/two=2/)
-      end
+        it 'should update cookies with rediects' do
+          @request.options[:headers] = {'Cookie' => 'foo=bar;'}
+          @redirect['Set-Cookie'] = 'foo=tar;'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/foo=tar/)
+        end
 
-      it 'should make resulting request a get request if it not already' do
-        @request.http_method = Net::HTTP::Delete
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-        expect(@request.http_method).to eq(Net::HTTP::Get)
-      end
+        it 'should keep cookies between rediects' do
+          @request.options[:headers] = {'Cookie' => 'keep=me'}
+          @redirect['Set-Cookie'] = 'foo=tar;'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/keep=me/)
+        end
 
-      it 'should not make resulting request a get request if options[:maintain_method_across_redirects] is true' do
-        @request.options[:maintain_method_across_redirects] = true
-        @request.http_method = Net::HTTP::Delete
-        expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
-        expect(@request.http_method).to eq(Net::HTTP::Delete)
-      end
+        it "should handle multiple Set-Cookie headers between redirects" do
+          @redirect.add_field 'set-cookie', 'foo=bar; name=value; HTTPOnly'
+          @redirect.add_field 'set-cookie', 'one=1; two=2; HTTPOnly'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/foo=bar/)
+          expect(@request.options[:headers]['Cookie']).to match(/name=value/)
+          expect(@request.options[:headers]['Cookie']).to match(/one=1/)
+          expect(@request.options[:headers]['Cookie']).to match(/two=2/)
+        end
 
-      it 'should log the redirection' do
-        logger_double = double
-        expect(logger_double).to receive(:info).twice
-        @request.options[:logger] = logger_double
-        @request.perform
-      end
-    end
+        it 'should make resulting request a get request if it not already' do
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+          expect(@request.http_method).to eq(Net::HTTP::Get)
+        end
 
-    describe "infinitely" do
-      before(:each) do
-        allow(@http).to receive(:request).and_return(@redirect)
+        it 'should not make resulting request a get request if options[:maintain_method_across_redirects] is true' do
+          @request.options[:maintain_method_across_redirects] = true
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+          expect(@request.http_method).to eq(Net::HTTP::Delete)
+        end
+
+        it 'should log the redirection' do
+          logger_double = double
+          expect(logger_double).to receive(:info).twice
+          @request.options[:logger] = logger_double
+          @request.perform
+        end
       end
 
-      it "should raise an exception" do
-        expect { @request.perform }.to raise_error(HTTParty::RedirectionTooDeep)
+      describe "infinitely" do
+        before(:each) do
+          allow(@http).to receive(:request).and_return(@redirect)
+        end
+
+        it "should raise an exception" do
+          expect { @request.perform }.to raise_error(HTTParty::RedirectionTooDeep)
+        end
       end
     end
   end
@@ -784,6 +794,197 @@ RSpec.describe HTTParty::Request do
     end
   end
 
+  describe "a request that returns 304" do
+    before(:each) do
+      @redirect = stub_response("", 304)
+      @redirect['location'] = '/foo'
+    end
+
+    before(:each) do
+      allow(@http).to receive(:request).and_return(@redirect)
+    end
+
+    it "should report 304 with a GET request" do
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a POST request" do
+      @request.http_method = Net::HTTP::Post
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a DELETE request" do
+      @request.http_method = Net::HTTP::Delete
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a MOVE request" do
+      @request.http_method = Net::HTTP::Move
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a COPY request" do
+      @request.http_method = Net::HTTP::Copy
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a PATCH request" do
+      @request.http_method = Net::HTTP::Patch
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a PUT request" do
+      @request.http_method = Net::HTTP::Put
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a HEAD request" do
+      @request.http_method = Net::HTTP::Head
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it "should report 304 with a OPTIONS request" do
+      @request.http_method = Net::HTTP::Options
+      expect(@request.perform.code).to eq(304)
+    end
+
+    it 'should not log the redirection' do
+      logger_double = double
+      expect(logger_double).to receive(:info).once
+      @request.options[:logger] = logger_double
+      @request.perform
+    end
+  end
+
+  [307, 308].each do |code|
+    describe "a request that #{code} redirects" do
+      before(:each) do
+        @redirect = stub_response("", code)
+        @redirect['location'] = '/foo'
+
+        @ok = stub_response('<hash><foo>bar</foo></hash>', 200)
+      end
+
+      describe "once" do
+        before(:each) do
+          allow(@http).to receive(:request).and_return(@redirect, @ok)
+        end
+
+        it "should be handled by GET transparently" do
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by POST transparently" do
+          @request.http_method = Net::HTTP::Post
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by DELETE transparently" do
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by MOVE transparently" do
+          @request.http_method = Net::HTTP::Move
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by COPY transparently" do
+          @request.http_method = Net::HTTP::Copy
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by PATCH transparently" do
+          @request.http_method = Net::HTTP::Patch
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by PUT transparently" do
+          @request.http_method = Net::HTTP::Put
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by HEAD transparently" do
+          @request.http_method = Net::HTTP::Head
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should be handled by OPTIONS transparently" do
+          @request.http_method = Net::HTTP::Options
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+        end
+
+        it "should keep track of cookies between redirects" do
+          @redirect['Set-Cookie'] = 'foo=bar; name=value; HTTPOnly'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/foo=bar/)
+          expect(@request.options[:headers]['Cookie']).to match(/name=value/)
+        end
+
+        it 'should update cookies with rediects' do
+          @request.options[:headers] = {'Cookie' => 'foo=bar;'}
+          @redirect['Set-Cookie'] = 'foo=tar;'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/foo=tar/)
+        end
+
+        it 'should keep cookies between rediects' do
+          @request.options[:headers] = {'Cookie' => 'keep=me'}
+          @redirect['Set-Cookie'] = 'foo=tar;'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/keep=me/)
+        end
+
+        it "should handle multiple Set-Cookie headers between redirects" do
+          @redirect.add_field 'set-cookie', 'foo=bar; name=value; HTTPOnly'
+          @redirect.add_field 'set-cookie', 'one=1; two=2; HTTPOnly'
+          @request.perform
+          expect(@request.options[:headers]['Cookie']).to match(/foo=bar/)
+          expect(@request.options[:headers]['Cookie']).to match(/name=value/)
+          expect(@request.options[:headers]['Cookie']).to match(/one=1/)
+          expect(@request.options[:headers]['Cookie']).to match(/two=2/)
+        end
+
+        it 'should maintain method in resulting request' do
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+          expect(@request.http_method).to eq(Net::HTTP::Delete)
+        end
+
+        it 'should maintain method in resulting request if options[:maintain_method_across_redirects] is false' do
+          @request.options[:maintain_method_across_redirects] = false
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+          expect(@request.http_method).to eq(Net::HTTP::Delete)
+        end
+
+        it 'should maintain method in resulting request if options[:maintain_method_across_redirects] is true' do
+          @request.options[:maintain_method_across_redirects] = true
+          @request.http_method = Net::HTTP::Delete
+          expect(@request.perform.parsed_response).to eq({"hash" => {"foo" => "bar"}})
+          expect(@request.http_method).to eq(Net::HTTP::Delete)
+        end
+
+        it 'should log the redirection' do
+          logger_double = double
+          expect(logger_double).to receive(:info).twice
+          @request.options[:logger] = logger_double
+          @request.perform
+        end
+      end
+
+      describe "infinitely" do
+        before(:each) do
+          allow(@http).to receive(:request).and_return(@redirect)
+        end
+
+        it "should raise an exception" do
+          expect { @request.perform }.to raise_error(HTTParty::RedirectionTooDeep)
+        end
+      end
+    end
+  end
+
   describe "#handle_deflation" do
     context "context-encoding" do
       before do

data/spec/httparty_spec.rb

@@ -351,6 +351,45 @@ RSpec.describe HTTParty do
     end
   end
 
+  describe "uri_adapter" do
+
+    require 'forwardable'
+    class CustomURIAdaptor
+      extend Forwardable
+      def_delegators :@uri, :userinfo, :relative?, :query, :query=, :scheme, :path, :host, :port
+
+      def initialize uri
+        @uri = uri
+      end
+
+      def self.parse uri
+        new URI.parse uri
+      end
+    end
+
+    let(:uri_adapter) { CustomURIAdaptor }
+
+    it "should set the uri_adapter" do
+      @klass.uri_adapter uri_adapter
+      expect(@klass.default_options[:uri_adapter]).to be uri_adapter
+    end
+
+    it "should raise an ArgumentError if uri_adapter doesn't implement parse method" do
+      expect do
+        @klass.uri_adapter double()
+      end.to raise_error(ArgumentError)
+    end
+
+
+    it "should process a request with a uri instance parsed from the uri_adapter" do
+      uri = 'http://foo.com/bar'
+      FakeWeb.register_uri(:get, uri, body: 'stuff')
+      @klass.uri_adapter uri_adapter
+      expect(@klass.get(uri).parsed_response).to eq('stuff')
+    end
+
+  end
+
   describe "connection_adapter" do
     let(:uri) { 'http://google.com/api.json' }
     let(:connection_adapter) { double('CustomConnectionAdapter') }
@@ -549,6 +588,33 @@ RSpec.describe HTTParty do
     end
   end
 
+  describe "head requests should follow redirects requesting HEAD only" do
+    before do
+      allow(HTTParty::Request).to receive(:new).
+        and_return(double("mock response", perform: nil))
+    end
+
+    it "should remain HEAD request across redirects, unless specified otherwise" do
+      expect(@klass).to receive(:ensure_method_maintained_across_redirects).with({})
+      @klass.head('/foo')
+    end
+
+  end
+
+  describe "#ensure_method_maintained_across_redirects" do
+    it "should set maintain_method_across_redirects option if unspecified" do
+      options = {}
+      @klass.send(:ensure_method_maintained_across_redirects, options)
+      expect(options[:maintain_method_across_redirects]).to be_truthy
+    end
+
+    it "should not set maintain_method_across_redirects option if value is present" do
+      options = { maintain_method_across_redirects: false }
+      @klass.send(:ensure_method_maintained_across_redirects, options)
+      expect(options[:maintain_method_across_redirects]).to be_falsey
+    end
+  end
+
   describe "with multiple class definitions" do
     before(:each) do
       @klass.instance_eval do
@@ -767,9 +833,11 @@ RSpec.describe HTTParty do
     end
 
     it "should accept webcal URIs" do
-      stub_http_response_with('google.html')
+      uri = 'http://google.com/'
+      FakeWeb.register_uri(:get, uri, body: 'stuff')
+      uri = 'webcal://google.com/'
       expect do
-        HTTParty.get('webcal://google.com')
+        HTTParty.get(uri)
       end.not_to raise_error
     end
 

data/spec/support/stub_response.rb

@@ -26,14 +26,20 @@ module HTTParty
       expect(HTTParty::Request).to receive(:new).and_return(http_request)
     end
 
-    def stub_response(body, code = 200)
+    def stub_response(body, code = '200')
+      code = code.to_s
       @request.options[:base_uri] ||= 'http://localhost'
       unless defined?(@http) && @http
         @http = Net::HTTP.new('localhost', 80)
         allow(@request).to receive(:http).and_return(@http)
       end
 
-      response = Net::HTTPResponse::CODE_TO_OBJ[code.to_s].new("1.1", code, body)
+      # CODE_TO_OBJ currently missing 308
+      if code == '308'
+        response = Net::HTTPRedirection.new("1.1", code, body)
+      else
+        response = Net::HTTPResponse::CODE_TO_OBJ[code].new("1.1", code, body)
+      end
       allow(response).to receive(:body).and_return(body)
 
       allow(@http).to receive(:request).and_return(response)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httparty
 version: !ruby/object:Gem::Version
-  version: 0.13.5
+  version: 0.13.6
 platform: ruby
 authors:
 - John Nunemaker
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-19 00:00:00.000000000 Z
+date: 2015-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -52,6 +52,7 @@ files:
 - ".rubocop_todo.yml"
 - ".simplecov"
 - ".travis.yml"
+- CONTRIBUTING.md
 - Gemfile
 - Guardfile
 - History
@@ -96,8 +97,8 @@ files:
 - lib/httparty/cookie_hash.rb
 - lib/httparty/exceptions.rb
 - lib/httparty/hash_conversions.rb
-- lib/httparty/logger/apache_logger.rb
-- lib/httparty/logger/curl_logger.rb
+- lib/httparty/logger/apache_formatter.rb
+- lib/httparty/logger/curl_formatter.rb
 - lib/httparty/logger/logger.rb
 - lib/httparty/module_inheritable_attributes.rb
 - lib/httparty/net_digest_auth.rb
@@ -127,8 +128,8 @@ files:
 - spec/httparty/cookie_hash_spec.rb
 - spec/httparty/exception_spec.rb
 - spec/httparty/hash_conversions_spec.rb
-- spec/httparty/logger/apache_logger_spec.rb
-- spec/httparty/logger/curl_logger_spec.rb
+- spec/httparty/logger/apache_formatter_spec.rb
+- spec/httparty/logger/curl_formatter_spec.rb
 - spec/httparty/logger/logger_spec.rb
 - spec/httparty/net_digest_auth_spec.rb
 - spec/httparty/parser_spec.rb
@@ -146,7 +147,7 @@ homepage: http://jnunemaker.github.com/httparty
 licenses:
 - MIT
 metadata: {}
-post_install_message: When you HTTParty, you must party hard!
+post_install_message: "When you HTTParty, you must party hard! \U0001F389"
 rdoc_options: []
 require_paths:
 - lib
@@ -201,8 +202,8 @@ test_files:
 - spec/httparty/cookie_hash_spec.rb
 - spec/httparty/exception_spec.rb
 - spec/httparty/hash_conversions_spec.rb
-- spec/httparty/logger/apache_logger_spec.rb
-- spec/httparty/logger/curl_logger_spec.rb
+- spec/httparty/logger/apache_formatter_spec.rb
+- spec/httparty/logger/curl_formatter_spec.rb
 - spec/httparty/logger/logger_spec.rb
 - spec/httparty/net_digest_auth_spec.rb
 - spec/httparty/parser_spec.rb