httparty 0.8.0 → 0.9.0

data/lib/httparty/connection_adapter.rb

@@ -0,0 +1,116 @@
+module HTTParty
+  # Default connection adapter that returns a new Net::HTTP each time
+  #
+  # == Custom Connection Factories
+  #
+  # If you like to implement your own connection adapter, subclassing
+  # HTTPParty::ConnectionAdapter will make it easier. Just override
+  # the #connection method. The uri and options attributes will have
+  # all the info you need to construct your http connection. Whatever
+  # you return from your connection method needs to adhere to the
+  # Net::HTTP interface as this is what HTTParty expects.
+  #
+  # @example log the uri and options
+  #   class LoggingConnectionAdapter < HTTParty::ConnectionAdapter
+  #     def connection
+  #       puts uri
+  #       puts options
+  #       Net::HTTP.new(uri)
+  #     end
+  #   end
+  #
+  # @example count number of http calls
+  #   class CountingConnectionAdapter < HTTParty::ConnectionAdapter
+  #     @@count = 0
+  #
+  #     self.count
+  #       @@count
+  #     end
+  #
+  #     def connection
+  #       self.count += 1
+  #       super
+  #     end
+  #   end
+  #
+  # === Configuration
+  # There is lots of configuration data available for your connection adapter
+  # 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:
+  # * :+timeout+: timeout in seconds
+  # * :+debug_output+: see HTTParty::ClassMethods.debug_output.
+  # * :+pem+: contains pem data. see HTTParty::ClassMethods.pem.
+  # * :+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
+  class ConnectionAdapter
+
+    def self.call(uri, options)
+      new(uri, options).connection
+    end
+
+    attr_reader :uri, :options
+
+    def initialize(uri, options={})
+      raise ArgumentError, "uri must be a URI, not a #{uri.class}" unless uri.kind_of? URI
+
+      @uri = uri
+      @options = options
+    end
+
+    def connection
+      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport], options[:http_proxyuser], options[:http_proxypass])
+
+      http.use_ssl = ssl_implied?(uri)
+
+      attach_ssl_certificates(http, options)
+
+      if options[:timeout] && (options[:timeout].is_a?(Integer) || options[:timeout].is_a?(Float))
+        http.open_timeout = options[:timeout]
+        http.read_timeout = options[:timeout]
+      end
+
+      if options[:debug_output]
+        http.set_debug_output(options[:debug_output])
+      end
+
+      return http
+    end
+
+    private
+    def ssl_implied?(uri)
+      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    end
+
+    def attach_ssl_certificates(http, options)
+      if http.use_ssl?
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        # Client certificate authentication
+        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
+        end
+
+        # SSL certificate authority file and/or directory
+        if options[:ssl_ca_file]
+          http.ca_file = options[:ssl_ca_file]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        if options[:ssl_ca_path]
+          http.ca_path = options[:ssl_ca_path]
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+
+        # This is only Ruby 1.9+
+        if options[:ssl_version] && http.respond_to?(:ssl_version=)
+          http.ssl_version = options[:ssl_version]
+        end
+      end
+    end
+  end
+end

data/lib/httparty/cookie_hash.rb

@@ -1,7 +1,7 @@
 class HTTParty::CookieHash < Hash #:nodoc:
-  
+
   CLIENT_COOKIES = %w{path expires domain path secure HTTPOnly}
-  
+
   def add_cookies(value)
     case value
     when Hash

data/lib/httparty/core_extensions.rb

@@ -6,4 +6,27 @@ module HTTParty
       instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval/ }
     end
   end
+
+  unless defined?(Net::HTTP::Patch)
+    class Net::HTTP
+      def patch(path, data, initheader = nil, dest = nil, &block) #:nodoc:
+        res = nil
+        request(Patch.new(path, initheader), data) {|r|
+          r.read_body dest, &block
+          res = r
+        }
+        unless @newimpl
+          res.value
+          return res, res.body
+        end
+        res
+      end
+
+      class Patch < Net::HTTPRequest
+        METHOD = 'PATCH'
+        REQUEST_HAS_BODY = true
+        RESPONSE_HAS_BODY = true
+      end
+    end
+  end
 end

data/lib/httparty/hash_conversions.rb

@@ -48,4 +48,4 @@ module HTTParty
       param
     end
   end
-end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -4,6 +4,16 @@ module HTTParty
       base.extend(ClassMethods)
     end
 
+    # borrowed from Rails 3.2 ActiveSupport
+    def self.hash_deep_dup(h)
+      duplicate = h.dup
+      duplicate.each_pair do |k,v|
+        tv = duplicate[k]
+        duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? hash_deep_dup(tv) : v
+      end
+      duplicate
+    end
+
     module ClassMethods #:nodoc:
       def mattr_inheritable(*args)
         @mattr_inheritable_attrs ||= [:mattr_inheritable_attrs]
@@ -22,7 +32,7 @@ module HTTParty
           if instance_variable_get(ivar).respond_to?(:merge)
             method = <<-EOM
               def self.#{inheritable_attribute}
-                #{ivar} = superclass.#{inheritable_attribute}.merge #{ivar}
+                #{ivar} = superclass.#{inheritable_attribute}.merge ModuleInheritableAttributes.hash_deep_dup(#{ivar})
               end
             EOM
             subclass.class_eval method

data/lib/httparty/net_digest_auth.rb

@@ -20,15 +20,24 @@ module Net
 
       def authorization_header
         @cnonce = md5(random)
-        header = [%Q(Digest username="#{@username}"),
+        header = [
+          %Q(Digest username="#{@username}"),
           %Q(realm="#{@response['realm']}"),
           %Q(nonce="#{@response['nonce']}"),
           %Q(uri="#{@path}"),
-          %Q(response="#{request_digest}")]
-        [%Q(cnonce="#{@cnonce}"),
-          %Q(opaque="#{@response['opaque']}"),
-          %Q(qop="#{@response['qop']}"),
-          %Q(nc="0")].each { |field| header << field } if qop_present?
+          %Q(response="#{request_digest}"),
+        ]
+
+        if qop_present?
+          fields = [
+            %Q(cnonce="#{@cnonce}"),
+            %Q(qop="#{@response['qop']}"),
+            %Q(nc="00000001")
+          ]
+          fields.each { |field| header << field }
+        end
+
+        header << %Q(opaque="#{@response['opaque']}") if opaque_present?
         header
       end
 
@@ -41,6 +50,10 @@ module Net
         params
       end
 
+      def opaque_present?
+        @response.has_key?('opaque') and not @response['opaque'].empty?
+      end
+
       def qop_present?
         @response.has_key?('qop') and not @response['qop'].empty?
       end
@@ -51,7 +64,7 @@ module Net
 
       def request_digest
         a = [md5(a1), @response['nonce'], md5(a2)]
-        a.insert(2, "0", @cnonce, @response['qop']) if qop_present?
+        a.insert(2, "00000001", @cnonce, @response['qop']) if qop_present?
         md5(a.join(":"))
       end
 

data/lib/httparty/parser.rb

@@ -93,12 +93,11 @@ module HTTParty
       @body = body
       @format = format
     end
-    private_class_method :new
 
     # @return [Object] the parsed body
-    # @return [nil] when the response body is nil or an empty string
+    # @return [nil] when the response body is nil, an empty string, spaces only or "null"
     def parse
-      return nil if body.nil? || body.empty?
+      return nil if body.nil? || body.strip.empty? || body == "null"
       if supports_format?
         parse_supported_format
       else
@@ -113,7 +112,12 @@ module HTTParty
     end
 
     def json
-      MultiJson.decode(body)
+      # https://github.com/sferik/rails/commit/5e62670131dfa1718eaf21ff8dd3371395a5f1cc
+      if MultiJson.respond_to?(:adapter)
+        MultiJson.load(body)
+      else
+        MultiJson.decode(body)
+      end
     end
 
     def yaml
@@ -134,8 +138,8 @@ module HTTParty
 
     def parse_supported_format
       send(format)
-    rescue NoMethodError
-      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format."
+    rescue NoMethodError => e
+      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format.", e.backtrace
     end
   end
 end

data/lib/httparty/request.rb

@@ -3,6 +3,7 @@ module HTTParty
     SupportedHTTPMethods = [
       Net::HTTP::Get,
       Net::HTTP::Post,
+      Net::HTTP::Patch,
       Net::HTTP::Put,
       Net::HTTP::Delete,
       Net::HTTP::Head,
@@ -32,7 +33,8 @@ module HTTParty
         :limit => o.delete(:no_follow) ? 1 : 5,
         :default_params => {},
         :follow_redirects => true,
-        :parser => Parser
+        :parser => Parser,
+        :connection_adapter => ConnectionAdapter
       }.merge(o)
     end
 
@@ -67,60 +69,36 @@ module HTTParty
       options[:parser]
     end
 
-    def perform
-      validate
-      setup_raw_request
-      self.last_response = http.request(@raw_request)
-      handle_deflation
-      handle_response
+    def connection_adapter
+      options[:connection_adapter]
     end
 
-    private
-
-    def attach_ssl_certificates(http)
-      if http.use_ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    def perform(&block)
+      validate
+      setup_raw_request
+      chunked_body = nil
 
-        # Client certificate authentication
-        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
-        end
+      self.last_response = http.request(@raw_request) do |http_response|
+        if block
+          chunks = []
 
-        # SSL certificate authority file and/or directory
-        if options[:ssl_ca_file]
-          http.ca_file = options[:ssl_ca_file]
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        end
+          http_response.read_body do |fragment|
+            chunks << fragment
+            block.call(fragment)
+          end
 
-        if options[:ssl_ca_path]
-          http.ca_path = options[:ssl_ca_path]
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          chunked_body = chunks.join
         end
       end
-    end
-
-    def http
-      http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
-      http.use_ssl = ssl_implied?
-
-      if options[:timeout] && (options[:timeout].is_a?(Integer) || options[:timeout].is_a?(Float))
-        http.open_timeout = options[:timeout]
-        http.read_timeout = options[:timeout]
-      end
-
-      attach_ssl_certificates(http)
-
-      if options[:debug_output]
-        http.set_debug_output(options[:debug_output])
-      end
 
-      http
+      handle_deflation
+      handle_response(chunked_body)
     end
 
-    def ssl_implied?
-      uri.port == 443 || uri.instance_of?(URI::HTTPS)
+    private
+
+    def http
+      connection_adapter.call(uri, options)
     end
 
     def body
@@ -160,7 +138,10 @@ module HTTParty
     end
 
     def setup_digest_auth
-      res = http.head(uri.request_uri, options[:headers])
+      auth_request = http_method.new(uri.request_uri)
+      auth_request.initialize_http_header(options[:headers])
+      res = http.request(auth_request)
+
       if res['www-authenticate'] != nil && res['www-authenticate'].length > 0
         @raw_request.digest_auth(username, password, res)
       end
@@ -180,8 +161,7 @@ module HTTParty
       query_string_parts.size > 0 ? query_string_parts.join('&') : nil
     end
 
-    # Raises exception Net::XXX (http error code) if an http error occured
-    def handle_response
+    def handle_response(body)
       if response_redirects?
         options[:limit] -= 1
         self.path = last_response['location']
@@ -190,18 +170,21 @@ module HTTParty
         capture_cookies(last_response)
         perform
       else
-        Response.new(self, last_response, parse_response(last_response.body))
+        body = body || last_response.body
+        Response.new(self, last_response, lambda { parse_response(body) }, :body => body)
       end
     end
 
     # Inspired by Ruby 1.9
     def handle_deflation
       case last_response["content-encoding"]
-      when "gzip"
+      when "gzip", "x-gzip"
         body_io = StringIO.new(last_response.body)
         last_response.body.replace Zlib::GzipReader.new(body_io).read
+        last_response.delete('content-encoding')
       when "deflate"
         last_response.body.replace Zlib::Inflate.inflate(last_response.body)
+        last_response.delete('content-encoding')
       end
     end
 
@@ -241,7 +224,7 @@ 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, put, delete, head, and options methods are supported' unless SupportedHTTPMethods.include?(http_method)
+      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, '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)

data/lib/httparty/response.rb

@@ -1,46 +1,21 @@
 module HTTParty
   class Response < HTTParty::BasicObject #:nodoc:
-    class Headers
-      include ::Net::HTTPHeader
-
-      def initialize(header)
-        @header = header
-      end
-
-      def ==(other)
-        @header == other
-      end
-
-      def inspect
-        @header.inspect
-      end
-
-      def method_missing(name, *args, &block)
-        if @header.respond_to?(name)
-          @header.send(name, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to?(method)
-        super || @header.respond_to?(method)
-      end
-    end
-
-
     def self.underscore(string)
       string.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
     end
 
-    attr_reader :request, :response, :parsed_response, :body, :headers
+    attr_reader :request, :response, :body, :headers
 
-    def initialize(request, response, parsed_response)
-      @request = request
-      @response = response
-      @body = response.body
-      @parsed_response = parsed_response
-      @headers = Headers.new(response.to_hash)
+    def initialize(request, response, parsed_block, options={})
+      @request      = request
+      @response     = response
+      @body         = response.body || options[:body]
+      @parsed_block = parsed_block
+      @headers      = Headers.new(response.to_hash)
+    end
+
+    def parsed_response
+      @parsed_response ||= @parsed_block.call
     end
 
     def class
@@ -53,7 +28,7 @@ module HTTParty
 
     def inspect
       inspect_id = "%x" % (object_id * 2)
-      %(#<#{self.class}:0x#{inspect_id} @parsed_response=#{parsed_response.inspect}, @response=#{response.inspect}, @headers=#{headers.inspect}>)
+      %(#<#{self.class}:0x#{inspect_id} parsed_response=#{parsed_response.inspect}, @response=#{response.inspect}, @headers=#{headers.inspect}>)
     end
 
     CODES_TO_OBJ = ::Net::HTTPResponse::CODE_CLASS_TO_OBJ.merge ::Net::HTTPResponse::CODE_TO_OBJ
@@ -64,10 +39,10 @@ module HTTParty
         klass === response
       end
     end
-    
+
     def respond_to?(name)
-      return true if [:request,:response,:parsed_response,:body,:headers].include?(name)
-      parsed_response.respond_to?(name) or response.respond_to?(name)
+      return true if [:request, :response, :parsed_response, :body, :headers].include?(name)
+      parsed_response.respond_to?(name) || response.respond_to?(name)
     end
 
     protected
@@ -83,3 +58,5 @@ module HTTParty
     end
   end
 end
+
+require 'httparty/response/headers'