httparty 0.13.7 → 0.24.2

data/lib/httparty/hash_conversions.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'erb'
+
 module HTTParty
   module HashConversions
     # @return <String> This hash as a query string
@@ -22,28 +26,46 @@ module HTTParty
     #
     # @example normalize_param(:name, "Bob Jones") #=> "name=Bob%20Jones&"
     def self.normalize_param(key, value)
-      param = ''
+      normalized_keys = normalize_keys(key, value)
+
+      normalized_keys.flatten.each_slice(2).inject(''.dup) do |string, (k, v)|
+        string << "#{ERB::Util.url_encode(k)}=#{ERB::Util.url_encode(v.to_s)}&"
+      end
+    end
+
+    def self.normalize_keys(key, value)
       stack = []
+      normalized_keys = []
 
       if value.respond_to?(:to_ary)
-        param << value.to_ary.map { |element| normalize_param("#{key}[]", element) }.join
+        if value.empty?
+          normalized_keys << ["#{key}[]", '']
+        else
+          normalized_keys = value.to_ary.flat_map do |element|
+            normalize_keys("#{key}[]", element)
+          end
+        end
       elsif value.respond_to?(:to_hash)
         stack << [key, value.to_hash]
       else
-        param << "#{key}=#{ERB::Util.url_encode(value.to_s)}&"
+        normalized_keys << [key.to_s, value]
       end
 
       stack.each do |parent, hash|
-        hash.each do |k, v|
-          if v.respond_to?(:to_hash)
-            stack << ["#{parent}[#{k}]", v.to_hash]
+        hash.each do |child_key, child_value|
+          if child_value.respond_to?(:to_hash)
+            stack << ["#{parent}[#{child_key}]", child_value.to_hash]
+          elsif child_value.respond_to?(:to_ary)
+            child_value.to_ary.each do |v|
+              normalized_keys << normalize_keys("#{parent}[#{child_key}][]", v).flatten
+            end
           else
-            param << normalize_param("#{parent}[#{k}]", v)
+            normalized_keys << normalize_keys("#{parent}[#{child_key}]", child_value).flatten
           end
         end
       end
 
-      param
+      normalized_keys
     end
   end
 end

data/lib/httparty/headers_processor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module HTTParty
+  class HeadersProcessor
+    attr_reader :headers, :options
+
+    def initialize(headers, options)
+      @headers = headers
+      @options = options
+    end
+
+    def call
+      return unless options[:headers]
+
+      options[:headers] = headers.merge(options[:headers]) if headers.any?
+      options[:headers] = Utils.stringify_keys(process_dynamic_headers)
+    end
+
+    private
+
+    def process_dynamic_headers
+      options[:headers].each_with_object({}) do |header, processed_headers|
+        key, value = header
+        processed_headers[key] = if value.respond_to?(:call)
+                                   value.arity == 0 ? value.call : value.call(options)
+                                 else
+                                   value
+                                 end
+      end
+    end
+  end
+end

data/lib/httparty/logger/apache_formatter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module HTTParty
   module Logger
     class ApacheFormatter #:nodoc:
       TAG_NAME = HTTParty.name
 
-      attr_accessor :level, :logger, :current_time
+      attr_accessor :level, :logger
 
       def initialize(logger, level)
         @logger = logger
@@ -11,11 +13,34 @@ module HTTParty
       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 || '-'} "
+        @request = request
+        @response = response
+
+        logger.public_send level, message
+      end
+
+      private
+
+      attr_reader :request, :response
+
+      def message
+        "[#{TAG_NAME}] [#{current_time}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
+      end
+
+      def current_time
+        Time.now.strftime('%Y-%m-%d %H:%M:%S %z')
+      end
+
+      def http_method
+        request.http_method.name.split('::').last.upcase
+      end
+
+      def path
+        request.path.to_s
+      end
+
+      def content_length
+        response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
       end
     end
   end

data/lib/httparty/logger/curl_formatter.rb

@@ -1,47 +1,92 @@
+# frozen_string_literal: true
+
 module HTTParty
   module Logger
     class CurlFormatter #:nodoc:
       TAG_NAME = HTTParty.name
-      OUT = ">"
-      IN = "<"
+      OUT      = '>'
+      IN       = '<'
 
-      attr_accessor :level, :logger, :current_time
+      attr_accessor :level, :logger
 
       def initialize(logger, level)
-        @logger = logger
-        @level  = level.to_sym
+        @logger   = logger
+        @level    = level.to_sym
+        @messages = []
       end
 
       def format(request, response)
-        messages        = []
-        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
+        @request  = request
+        @response = response
 
-        messages << print(time, OUT, "#{http_method} #{path}")
+        log_request
+        log_response
 
-        if request.options[:headers] && request.options[:headers].size > 0
-          request.options[:headers].each do |k, v|
-            messages << print(time, OUT, "#{k}: #{v}")
-          end
-        end
+        logger.public_send level, messages.join("\n")
+      end
+
+      private
+
+      attr_reader :request, :response
+      attr_accessor :messages
 
-        messages << print(time, OUT, request.raw_body)
-        messages << print(time, OUT, "")
-        messages << print(time, IN, "HTTP/#{response.http_version} #{response.code}")
+      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|
-          messages << print(time, IN, "#{response_header.capitalize}: #{headers[response_header]}")
+          log IN, "#{response_header.capitalize}: #{headers[response_header]}"
         end
+      end
 
-        messages << print(time, IN, "\n#{response.body}")
+      def log_hash(hash)
+        hash.each { |k, v| log(OUT, "#{k}: #{v}") }
+      end
 
-        @logger.send @level, messages.join("\n")
+      def log(direction, line = '')
+        messages << "[#{TAG_NAME}] [#{current_time}] #{direction} #{line}"
       end
 
-      def print(time, direction, line)
-        "[#{TAG_NAME}] [#{time}] #{direction} #{line}"
+      def current_time
+        Time.now.strftime("%Y-%m-%d %H:%M:%S %z")
       end
     end
   end

data/lib/httparty/logger/logger.rb

@@ -1,12 +1,16 @@
+# frozen_string_literal: true
+
 require 'httparty/logger/apache_formatter'
 require 'httparty/logger/curl_formatter'
+require 'httparty/logger/logstash_formatter'
 
 module HTTParty
   module Logger
     def self.formatters
       @formatters ||= {
         :curl => Logger::CurlFormatter,
-        :apache => Logger::ApacheFormatter
+        :apache => Logger::ApacheFormatter,
+        :logstash => Logger::LogstashFormatter,
       }
     end
 

data/lib/httparty/logger/logstash_formatter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module HTTParty
+  module Logger
+    class LogstashFormatter #:nodoc:
+      TAG_NAME = HTTParty.name
+
+      attr_accessor :level, :logger
+
+      def initialize(logger, level)
+        @logger = logger
+        @level  = level.to_sym
+      end
+
+      def format(request, response)
+        @request = request
+        @response = response
+
+        logger.public_send level, logstash_message
+      end
+
+      private
+
+      attr_reader :request, :response
+
+      def logstash_message
+        require 'json'
+        {
+          '@timestamp' => current_time,
+          '@version' => 1,
+          'content_length' => content_length || '-',
+          'http_method' => http_method,
+          'message' => message,
+          'path' => path,
+          'response_code' => response.code,
+          'severity' => level,
+          'tags' => [TAG_NAME],
+        }.to_json
+      end
+
+      def message
+        "[#{TAG_NAME}] #{response.code} \"#{http_method} #{path}\" #{content_length || '-'} "
+      end
+
+      def current_time
+        Time.now.strftime('%Y-%m-%d %H:%M:%S %z')
+      end
+
+      def http_method
+        @http_method ||= request.http_method.name.split('::').last.upcase
+      end
+
+      def path
+        @path ||= request.path.to_s
+      end
+
+      def content_length
+        @content_length ||= response.respond_to?(:headers) ? response.headers['Content-Length'] : response['Content-Length']
+      end
+    end
+  end
+end

data/lib/httparty/module_inheritable_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTTParty
   module ModuleInheritableAttributes #:nodoc:
     def self.included(base)
@@ -9,12 +11,12 @@ module HTTParty
       duplicate = hash.dup
 
       duplicate.each_pair do |key, value|
-        duplicate[key] = if value.is_a?(Hash)
-                           hash_deep_dup(value)
+        if value.is_a?(Hash)
+          duplicate[key] = hash_deep_dup(value)
         elsif value.is_a?(Proc)
           duplicate[key] = value.dup
         else
-          value
+          duplicate[key] = value
         end
       end
 
@@ -27,7 +29,7 @@ module HTTParty
         @mattr_inheritable_attrs += args
 
         args.each do |arg|
-          module_eval %(class << self; attr_accessor :#{arg} end)
+          singleton_class.attr_accessor(arg)
         end
 
         @mattr_inheritable_attrs
@@ -36,18 +38,16 @@ module HTTParty
       def inherited(subclass)
         super
         @mattr_inheritable_attrs.each do |inheritable_attribute|
-          ivar = "@#{inheritable_attribute}"
+          ivar = :"@#{inheritable_attribute}"
           subclass.instance_variable_set(ivar, instance_variable_get(ivar).clone)
 
           if instance_variable_get(ivar).respond_to?(:merge)
-            method = <<-EOM
+            subclass.class_eval <<~RUBY, __FILE__, __LINE__ + 1
               def self.#{inheritable_attribute}
                 duplicate = ModuleInheritableAttributes.hash_deep_dup(#{ivar})
                 #{ivar} = superclass.#{inheritable_attribute}.merge(duplicate)
               end
-            EOM
-
-            subclass.class_eval method
+            RUBY
           end
         end
       end

data/lib/httparty/net_digest_auth.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'digest/md5'
 require 'net/http'
 
@@ -12,13 +14,13 @@ module Net
         response
       )
 
-      @header['Authorization'] = authenticator.authorization_header
-      @header['cookie'] = append_cookies(authenticator) if response['Set-Cookie']
-    end
+      authenticator.authorization_header.each do |v|
+        add_field('Authorization', v)
+      end
 
-    def append_cookies(authenticator)
-      cookies = @header['cookie'] ? @header['cookie'] : []
-      cookies.concat(authenticator.cookie_header)
+      authenticator.cookie_header.each do |v|
+        add_field('Cookie', v)
+      end
     end
 
     class DigestAuthenticator
@@ -44,12 +46,9 @@ module Net
         header << %(algorithm="#{@response['algorithm']}") if algorithm_present?
 
         if qop_present?
-          fields = [
-            %(cnonce="#{@cnonce}"),
-            %(qop="#{@response['qop']}"),
-            "nc=00000001"
-          ]
-          fields.each { |field| header << field }
+          header << %(cnonce="#{@cnonce}")
+          header << %(qop="#{@response['qop']}")
+          header << 'nc=00000001'
         end
 
         header << %(opaque="#{@response['opaque']}") if opaque_present?
@@ -64,12 +63,15 @@ module Net
 
       def parse(response_header)
         header = response_header['www-authenticate']
-                 .gsub(/qop=(auth(?:-int)?)/, 'qop="\\1"')
+
+        header = header.gsub(/qop=(auth(?:-int)?)/, 'qop="\\1"')
 
         header =~ /Digest (.*)/
         params = {}
-        non_quoted = $1.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
-        non_quoted.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
 
@@ -95,13 +97,13 @@ module Net
       end
 
       def random
-        format "%x", (Time.now.to_i + rand(65535))
+        format '%x', (Time.now.to_i + rand(65535))
       end
 
       def request_digest
         a = [md5(a1), @response['nonce'], md5(a2)]
-        a.insert(2, "00000001", @cnonce, @response['qop']) if qop_present?
-        md5(a.join(":"))
+        a.insert(2, '00000001', @cnonce, @response['qop']) if qop_present?
+        md5(a.join(':'))
       end
 
       def md5(str)
@@ -111,11 +113,11 @@ module Net
       def algorithm_present?
         @response.key?('algorithm') && !@response['algorithm'].empty?
       end
-      
+
       def use_md5_sess?
         algorithm_present? && @response['algorithm'] == 'MD5-sess'
       end
-      
+
       def a1
         a1_user_realm_pwd =  [@username, @response['realm'], @password].join(':')
         if use_md5_sess?
@@ -126,7 +128,7 @@ module Net
       end
 
       def a2
-        [@method, @path].join(":")
+        [@method, @path].join(':')
       end
     end
   end

data/lib/httparty/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module HTTParty
   # The default parser used by HTTParty, supports xml, json, html, csv and
   # plain text.
@@ -38,16 +40,18 @@ module HTTParty
   # @abstract Read the Custom Parsers section for more information.
   class Parser
     SupportedFormats = {
-      'text/xml'               => :xml,
-      'application/xml'        => :xml,
-      'application/json'       => :json,
-      'text/json'              => :json,
-      'application/javascript' => :plain,
-      'text/javascript'        => :plain,
-      'text/html'              => :html,
-      'text/plain'             => :plain,
-      'text/csv'               => :csv,
-      'application/csv'        => :csv,
+      'text/xml'                    => :xml,
+      'application/xml'             => :xml,
+      'application/json'            => :json,
+      'application/vnd.api+json'    => :json,
+      'application/hal+json'        => :json,
+      'text/json'                   => :json,
+      'application/javascript'      => :plain,
+      'text/javascript'             => :plain,
+      'text/html'                   => :html,
+      'text/plain'                  => :plain,
+      'text/csv'                    => :csv,
+      'application/csv'             => :csv,
       'text/comma-separated-values' => :csv
     }
 
@@ -99,8 +103,11 @@ module HTTParty
     # @return [nil] when the response body is nil, an empty string, spaces only or "null"
     def parse
       return nil if body.nil?
-      return nil if body == "null"
+      return nil if body == 'null'
       return nil if body.valid_encoding? && body.strip.empty?
+      if body.valid_encoding? && body.encoding == Encoding::UTF_8
+        @body = body.gsub(/\A#{UTF8_BOM}/, '')
+      end
       if supports_format?
         parse_supported_format
       else
@@ -111,14 +118,19 @@ module HTTParty
     protected
 
     def xml
+      require 'multi_xml'
       MultiXml.parse(body)
     end
 
+    UTF8_BOM = "\xEF\xBB\xBF"
+
     def json
+      require 'json'
       JSON.parse(body, :quirks_mode => true, :allow_nan => true)
     end
 
     def csv
+      require 'csv'
       CSV.parse(body)
     end
 
@@ -135,9 +147,11 @@ module HTTParty
     end
 
     def parse_supported_format
-      send(format)
-    rescue NoMethodError => e
-      raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format.", e.backtrace
+      if respond_to?(format, true)
+        send(format)
+      else
+        raise NotImplementedError, "#{self.class.name} has not implemented a parsing method for the #{format.inspect} format."
+      end
     end
   end
 end