httparty 0.13.6 → 0.21.0

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,61 @@
+# 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
+        {
+          '@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
 
@@ -36,7 +38,7 @@ 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)

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
@@ -114,6 +121,8 @@ module HTTParty
       MultiXml.parse(body)
     end
 
+    UTF8_BOM = "\xEF\xBB\xBF"
+
     def json
       JSON.parse(body, :quirks_mode => true, :allow_nan => true)
     end
@@ -135,9 +144,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

data/lib/httparty/request/body.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative 'multipart_boundary'
+
+module HTTParty
+  class Request
+    class Body
+      NEWLINE = "\r\n"
+      private_constant :NEWLINE
+
+      def initialize(params, query_string_normalizer: nil, force_multipart: false)
+        @params = params
+        @query_string_normalizer = query_string_normalizer
+        @force_multipart = force_multipart
+      end
+
+      def call
+        if params.respond_to?(:to_hash)
+          multipart? ? generate_multipart : normalize_query(params)
+        else
+          params
+        end
+      end
+
+      def boundary
+        @boundary ||= MultipartBoundary.generate
+      end
+
+      def multipart?
+        params.respond_to?(:to_hash) && (force_multipart || has_file?(params))
+      end
+
+      private
+
+      # https://html.spec.whatwg.org/#multipart-form-data
+      MULTIPART_FORM_DATA_REPLACEMENT_TABLE = {
+        '"'  => '%22',
+        "\r" => '%0D',
+        "\n" => '%0A'
+      }.freeze
+
+      def generate_multipart
+        normalized_params = params.flat_map { |key, value| HashConversions.normalize_keys(key, value) }
+
+        multipart = normalized_params.inject(''.dup) do |memo, (key, value)|
+          memo << "--#{boundary}#{NEWLINE}"
+          memo << %(Content-Disposition: form-data; name="#{key}")
+          # value.path is used to support ActionDispatch::Http::UploadedFile
+          # https://github.com/jnunemaker/httparty/pull/585
+          memo << %(; filename="#{file_name(value).gsub(/["\r\n]/, MULTIPART_FORM_DATA_REPLACEMENT_TABLE)}") if file?(value)
+          memo << NEWLINE
+          memo << "Content-Type: #{content_type(value)}#{NEWLINE}" if file?(value)
+          memo << NEWLINE
+          memo << content_body(value)
+          memo << NEWLINE
+        end
+
+        multipart << "--#{boundary}--#{NEWLINE}"
+      end
+
+      def has_file?(value)
+        if value.respond_to?(:to_hash)
+          value.to_hash.any? { |_, v| has_file?(v) }
+        elsif value.respond_to?(:to_ary)
+          value.to_ary.any? { |v| has_file?(v) }
+        else
+          file?(value)
+        end
+      end
+
+      def file?(object)
+        object.respond_to?(:path) && object.respond_to?(:read)
+      end
+
+      def normalize_query(query)
+        if query_string_normalizer
+          query_string_normalizer.call(query)
+        else
+          HashConversions.to_params(query)
+        end
+      end
+
+      def content_body(object)
+        if file?(object)
+          object = (file = object).read
+          file.rewind if file.respond_to?(:rewind)
+        end
+
+        object.to_s
+      end
+
+      def content_type(object)
+        return object.content_type if object.respond_to?(:content_type)
+        mime = MiniMime.lookup_by_filename(object.path)
+        mime ? mime.content_type : 'application/octet-stream'
+      end
+
+      def file_name(object)
+        object.respond_to?(:original_filename) ? object.original_filename : File.basename(object.path)
+      end
+
+      attr_reader :params, :query_string_normalizer, :force_multipart
+    end
+  end
+end

data/lib/httparty/request/multipart_boundary.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module HTTParty
+  class Request
+    class MultipartBoundary
+      def self.generate
+        "------------------------#{SecureRandom.urlsafe_base64(12)}"
+      end
+    end
+  end
+end