httparty 0.10.0 → 0.14.0

data/lib/httparty/logger/apache_formatter.rb

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

data/lib/httparty/logger/curl_formatter.rb

@@ -0,0 +1,91 @@
+module HTTParty
+  module Logger
+    class CurlFormatter #:nodoc:
+      TAG_NAME = HTTParty.name
+      OUT      = '>'.freeze
+      IN       = '<'.freeze
+
+      attr_accessor :level, :logger
+
+      def initialize(logger, level)
+        @logger   = logger
+        @level    = level.to_sym
+        @messages = []
+      end
+
+      def format(request, response)
+        @request  = request
+        @response = response
+
+        log_request
+        log_response
+
+        logger.send level, messages.join("\n")
+      end
+
+      private
+
+      attr_reader :request, :response
+      attr_accessor :messages
+
+      def log_request
+        log_url
+        log_headers
+        log_query
+        log OUT, request.raw_body if request.raw_body
+        log OUT
+      end
+
+      def log_response
+        log IN, "HTTP/#{response.http_version} #{response.code}"
+        log_response_headers
+        log IN, "\n#{response.body}"
+        log IN
+      end
+
+      def log_url
+        http_method = request.http_method.name.split("::").last.upcase
+        uri = if request.options[:base_uri]
+                request.options[:base_uri] + request.path.path
+              else
+                request.path.to_s
+              end
+
+        log OUT, "#{http_method} #{uri}"
+      end
+
+      def log_headers
+        return unless request.options[:headers] && request.options[:headers].size > 0
+
+        log OUT, 'Headers: '
+        log_hash request.options[:headers]
+      end
+
+      def log_query
+        return unless request.options[:query]
+
+        log OUT, 'Query: '
+        log_hash request.options[:query]
+      end
+
+      def log_response_headers
+        headers = response.respond_to?(:headers) ? response.headers : response
+        response.each_header do |response_header|
+          log IN, "#{response_header.capitalize}: #{headers[response_header]}"
+        end
+      end
+
+      def log_hash(hash)
+        hash.each { |k, v| log(OUT, "#{k}: #{v}") }
+      end
+
+      def log(direction, line = '')
+        messages << "[#{TAG_NAME}] [#{time}] #{direction} #{line}"
+      end
+
+      def time
+        @time ||= Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
+      end
+    end
+  end
+end

data/lib/httparty/logger/logger.rb

@@ -0,0 +1,26 @@
+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
+
+      logger_klass = formatters[formatter] || Logger::ApacheFormatter
+      logger_klass.new(logger, level)
+    end
+  end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -10,7 +10,7 @@ module HTTParty
 
       duplicate.each_pair do |key, value|
         duplicate[key] = if value.is_a?(Hash)
-          hash_deep_dup(value)
+                           hash_deep_dup(value)
         elsif value.is_a?(Proc)
           duplicate[key] = value.dup
         else

data/lib/httparty/net_digest_auth.rb

@@ -4,10 +4,22 @@ require 'net/http'
 module Net
   module HTTPHeader
     def digest_auth(username, password, response)
-      @header['Authorization'] = DigestAuthenticator.new(username, password,
-          @method, @path, response).authorization_header
+      authenticator = DigestAuthenticator.new(
+        username,
+        password,
+        @method,
+        @path,
+        response
+      )
+
+      @header['Authorization'] = authenticator.authorization_header
+      @header['cookie'] = append_cookies(authenticator) if response['Set-Cookie']
     end
 
+    def append_cookies(authenticator)
+      cookies = @header['cookie'] ? @header['cookie'] : []
+      cookies.concat(authenticator.cookie_header)
+    end
 
     class DigestAuthenticator
       def initialize(username, password, method, path, response_header)
@@ -16,50 +28,76 @@ module Net
         @method   = method
         @path     = path
         @response = parse(response_header)
+        @cookies  = parse_cookies(response_header)
       end
 
       def authorization_header
         @cnonce = md5(random)
         header = [
-          %Q(Digest username="#{@username}"),
-          %Q(realm="#{@response['realm']}"),
-          %Q(nonce="#{@response['nonce']}"),
-          %Q(uri="#{@path}"),
-          %Q(response="#{request_digest}"),
+          %(Digest username="#{@username}"),
+          %(realm="#{@response['realm']}"),
+          %(nonce="#{@response['nonce']}"),
+          %(uri="#{@path}"),
+          %(response="#{request_digest}")
         ]
 
+        header << %(algorithm="#{@response['algorithm']}") if algorithm_present?
+
         if qop_present?
           fields = [
-            %Q(cnonce="#{@cnonce}"),
-            %Q(qop="#{@response['qop']}"),
-            %Q(nc="00000001")
+            %(cnonce="#{@cnonce}"),
+            %(qop="#{@response['qop']}"),
+            "nc=00000001"
           ]
           fields.each { |field| header << field }
         end
 
-        header << %Q(opaque="#{@response['opaque']}") if opaque_present?
+        header << %(opaque="#{@response['opaque']}") if opaque_present?
         header
       end
 
-    private
+      def cookie_header
+        @cookies
+      end
+
+      private
 
       def parse(response_header)
-        response_header['www-authenticate'] =~ /^(\w+) (.*)/
+        header = response_header['www-authenticate']
+                 .gsub(/qop=(auth(?:-int)?)/, 'qop="\\1"')
+
+        header =~ /Digest (.*)/
         params = {}
-        $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+        if $1
+          non_quoted = $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+          non_quoted.gsub(/(\w+)=([^,]*)/) { params[$1] = $2 }
+        end
         params
       end
 
+      def parse_cookies(response_header)
+        return [] unless response_header['Set-Cookie']
+
+        cookies = response_header['Set-Cookie'].split('; ')
+
+        cookies.reduce([]) do |ret, cookie|
+          ret << cookie
+          ret
+        end
+
+        cookies
+      end
+
       def opaque_present?
-        @response.has_key?('opaque') and not @response['opaque'].empty?
+        @response.key?('opaque') && !@response['opaque'].empty?
       end
 
       def qop_present?
-        @response.has_key?('qop') and not @response['qop'].empty?
+        @response.key?('qop') && !@response['qop'].empty?
       end
 
       def random
-        "%x" % (Time.now.to_i + rand(65535))
+        format "%x", (Time.now.to_i + rand(65535))
       end
 
       def request_digest
@@ -72,8 +110,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

@@ -1,5 +1,5 @@
 module HTTParty
-  # The default parser used by HTTParty, supports xml, json, html, and
+  # The default parser used by HTTParty, supports xml, json, html, csv and
   # plain text.
   #
   # == Custom Parsers
@@ -42,10 +42,13 @@ module HTTParty
       'application/xml'        => :xml,
       'application/json'       => :json,
       'text/json'              => :json,
-      'application/javascript' => :json,
-      'text/javascript'        => :json,
+      'application/javascript' => :plain,
+      'text/javascript'        => :plain,
       'text/html'              => :html,
-      'text/plain'             => :plain
+      'text/plain'             => :plain,
+      'text/csv'               => :csv,
+      'application/csv'        => :csv,
+      'text/comma-separated-values' => :csv
     }
 
     # The response body of the request
@@ -95,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
@@ -110,12 +115,11 @@ module HTTParty
     end
 
     def json
-      # https://github.com/sferik/rails/commit/5e62670131dfa1718eaf21ff8dd3371395a5f1cc
-      if MultiJson.respond_to?(:adapter)
-        MultiJson.load(body)
-      else
-        MultiJson.decode(body)
-      end
+      JSON.parse(body, :quirks_mode => true, :allow_nan => true)
+    end
+
+    def csv
+      CSV.parse(body)
     end
 
     def html