patron 0.14.0 → 1.0.0

data/lib/patron/response_decoding.rb

@@ -1,102 +1,95 @@
+# frozen_string_literal: true
+
 module Patron
   # Contains methods used for decoding the HTTP response body. These are only ever used internally
   # by the Response class.
   module ResponseDecoding
-    
+
     private
 
-    CHARSET_CONTENT_TYPE_RE = /(?:charset|encoding)="?([a-z0-9-]+)"?/i.freeze
-    
-    MISREPORTED_ENCODING_ERROR = <<-EOF
-The server stated that the response has the charset matching %{declared}, but the actual
-response body failed to decode as such (not flagged as `valid_encoding?')
-Maybe the response body has a different encoding than suggested by the
-server, or a binary response has been tagged by the server as text by mistake.
-If you are performing requests against servers that are known to report wrong or invalid charsets, use
-`Response#body' instead and handle the character set coercion externally. For instance, you may elect to parse
-the resulting HTML/XML for charset declarations.
-EOF
-  
-    INVALID_CHARSET_NAME_ERROR = <<-EOF
-The server specified an invalid charset in the Content-Type header (%{content_type}), \
-or Ruby does not support this charset. If you are performing requests against servers \
-that are known to report wrong or invalid charsets, use 'Response#body` instead \
-and handle the character set coercion at call site.
-EOF
-    
-    INTERNAL_CHARSET_MISMATCH_ERROR = <<-EOF
-The response body is %{source_encoding}, but the current \
-`Encoding.default_internal' (or the encoding for a new empty string if you never \
-set `Encoding.default_internal') - %{target_encoding} - cannot be used to represent the response body in \
-a lossless way. Your options are:
-a) using `Response#body' instead
-b) switching your Ruby process to an encoding that supports the needed repertoire
-c) using `Response#inspectable_body' to convert the body in a lossy way
-EOF
+    CHARSET_CONTENT_TYPE_RE = /(?:charset|encoding)="?([a-z0-9-]+)"?/i
+
+    MISREPORTED_ENCODING_ERROR = <<~EOF
+      The server stated that the response has the charset matching %{declared}, but the actual
+      response body failed to decode as such (not flagged as `valid_encoding?')
+      Maybe the response body has a different encoding than suggested by the
+      server, or a binary response has been tagged by the server as text by mistake.
+      If you are performing requests against servers that are known to report wrong or invalid charsets, use
+      `Response#body' instead and handle the character set coercion externally. For instance, you may elect to parse
+      the resulting HTML/XML for charset declarations.
+    EOF
+
+    INVALID_CHARSET_NAME_ERROR = <<~EOF
+      The server specified an invalid charset in the Content-Type header (%{content_type}), \
+      or Ruby does not support this charset. If you are performing requests against servers \
+      that are known to report wrong or invalid charsets, use 'Response#body` instead \
+      and handle the character set coercion at call site.
+    EOF
+
+    INTERNAL_CHARSET_MISMATCH_ERROR = <<~EOF
+      The response body is %{source_encoding}, but the current \
+      `Encoding.default_internal' (or the encoding for a new empty string if you never \
+      set `Encoding.default_internal') - %{target_encoding} - cannot be used to represent the response body in \
+      a lossless way. Your options are:
+      a) using `Response#body' instead
+      b) switching your Ruby process to an encoding that supports the needed repertoire
+      c) using `Response#inspectable_body' to convert the body in a lossy way
+    EOF
 
     def decode_body(strict)
-      # Try to detect the body encoding from headers
       body_encoding = encoding_from_headers_or_binary
-  
-      # See if the body actually _is_ in this encoding. 
-      encoding_matched = @body.force_encoding(body_encoding).valid_encoding?
-      if !encoding_matched
-        raise HeaderCharsetInvalid,  MISREPORTED_ENCODING_ERROR % {declared: body_encoding}
+
+      # Re-tag a copy, so that #body stays binary no matter what the server claimed
+      tagged = @body.dup.force_encoding(body_encoding)
+      unless tagged.valid_encoding?
+        raise HeaderCharsetInvalid, MISREPORTED_ENCODING_ERROR % { declared: body_encoding }
       end
-  
+
       if strict
-        convert_encoding_and_raise(@body)
+        convert_encoding_and_raise(tagged)
       else
-        @body.encode(internal_encoding, :undefined => :replace, :replace => '?')
+        tagged.encode(internal_encoding, undefined: :replace, replace: '?')
       end
     end
 
     def convert_encoding_and_raise(str)
       internal = internal_encoding
       str.encode(internal)
-    rescue Encoding::UndefinedConversionError => e
+    rescue Encoding::UndefinedConversionError
       enc = str.encoding == Encoding::BINARY ? 'binary' : str.encoding.to_s
       raise NonRepresentableBody,
-        INTERNAL_CHARSET_MISMATCH_ERROR % {source_encoding: enc, target_encoding: internal}
+        INTERNAL_CHARSET_MISMATCH_ERROR % { source_encoding: enc, target_encoding: internal }
     end
-    
+
     def charset_from_content_type
-      return $1 if @headers["Content-Type"].to_s =~ CHARSET_CONTENT_TYPE_RE
+      @headers["Content-Type"].to_s[CHARSET_CONTENT_TYPE_RE, 1]
     end
-    
+
     def encoding_from_headers_or_binary
-      return Encoding::BINARY unless charset_name = charset_from_content_type
+      return Encoding::BINARY unless (charset_name = charset_from_content_type)
       Encoding.find(charset_name)
-    rescue ArgumentError => e # invalid charset name
+    rescue ArgumentError # invalid charset name
       raise HeaderCharsetInvalid,
-            INVALID_CHARSET_NAME_ERROR % {content_type: @headers['Content-Type'].inspect}
+            INVALID_CHARSET_NAME_ERROR % { content_type: @headers['Content-Type'].inspect }
     end
-    
+
     def internal_encoding
-      # Use a trick here - instead of using `default_internal` we will create
-      # an empty string, and then get it's encoding instead. For example, this holds
-      # true on 2.1+ on OSX:
-      #
-      #     Encoding.default_internal #=> nil
-      #     ''.encoding #=> #<Encoding:UTF-8>
+      # `Encoding.default_internal` is nil on a stock Ruby while a new empty String is UTF-8,
+      # so the String is the better oracle for "what does this process speak"
       Encoding.default_internal || ''.encoding
     end
-    
+
     def decode_header_data(str)
-      # Header data is tricky. Strictly speaking, it _must_ be ISO-encoded. However, Content-Disposition
-      # sometimes gets sent as raw UTF8 - and most browsers (except for localized IE versions on Windows)
-      # treat it as such. So a fallback chain of 8859-1->UTF8->binary seems the most sane.
-      tries = [Encoding::ISO8859_1, Encoding::UTF_8, Encoding::BINARY]
-      tries.each do |possible_enc|
-        begin
-          return str.encode(possible_enc)
-        rescue ::Encoding::UndefinedConversionError
-          next
-        end
+      # Headers are ISO-8859-1 by the book, but Content-Disposition routinely arrives as raw UTF-8
+      # and every browser but localized IE treats it as such, so 8859-1 -> UTF-8 -> binary it is
+      [Encoding::ISO8859_1, Encoding::UTF_8, Encoding::BINARY].each do |possible_enc|
+        return str.encode(possible_enc)
+      rescue ::Encoding::UndefinedConversionError
+        next
       end
-      str # if it doesn't encode, just give back what we got
+      str
     end
   end
-  
-  private_constant :ResponseDecoding if respond_to?(:private_constant)
+
+  private_constant :ResponseDecoding
 end

data/lib/patron/session.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'uri'
 require 'patron/error'
 require 'patron/request'
@@ -6,17 +8,24 @@ require 'patron/response'
 require 'patron/session_ext'
 require 'patron/util'
 require 'patron/header_parser'
+require 'patron/compat'
 
 module Patron
 
   # This class represents multiple request/response transactions with an HTTP
   # server. This is the primary API for Patron.
+  #
+  # A Session owns a libcurl multi handle with its connection cache, so requests to the
+  # same host reuse connections. A Session performs one request at a time: use one Session
+  # per thread (or per fiber). Performing a request while another thread is already
+  # performing one on the same Session raises Patron::Error. A Session belongs to the Ractor
+  # that created it and cannot be sent to or shared with another one; Requests and Responses can.
   class Session
 
-    # @return [Integer] HTTP connection timeout in seconds. Defaults to 1 second.
+    # @return [Numeric] HTTP connection timeout in seconds. Defaults to 1 second.
     attr_accessor :connect_timeout
 
-    # @return [Integer] HTTP transaction timeout in seconds. Defaults to 5 seconds.
+    # @return [Numeric] HTTP transaction timeout in seconds. Defaults to 5 seconds.
     attr_accessor :timeout
 
     # @return [Integer] DNS cache timeout in seconds. Defaults to 60 seconds. Set to 0 for no cache, or to -1 for indefinite caching.
@@ -33,7 +42,7 @@ module Patron
     # Username for http authentication
     # @return [String,nil] the HTTP basic auth username
     attr_accessor :username
-    
+
     # Password for http authentication
     # @return [String,nil] the HTTP basic auth password
     attr_accessor :password
@@ -48,7 +57,7 @@ module Patron
     # @return [Hash] headers used in all requests.
     attr_accessor :headers
 
-    # @return [Symbol] the authentication type for the request (`:basic`, `:digest` or `:token`).
+    # @return [Symbol] the authentication type for the request (`:basic`, `:digest` or `:any`).
     # @see Patron::Request#auth_type
     attr_accessor :auth_type
 
@@ -56,12 +65,14 @@ module Patron
     # Please consider twice before using this option..
     attr_accessor :insecure
 
-    # @return [String] the SSL version for the requests, or nil if all versions are permitted
-    # The supported values are nil, "SSLv2", "SSLv3", and "TLSv1".
+    # @return [String] the SSL version for the requests, or nil if all versions are permitted.
+    # The supported values are the keys of Patron::Request::SSL_VERSIONS:
+    # "TLSv1", "TLSv1_0", "TLSv1_1", "TLSv1_2" and "TLSv1_3".
     attr_accessor :ssl_version
 
-    # @return [String] the HTTP version for the requests, or "None" if libcurl is to choose permitted versions
-    # The supported values are "None", "HTTPv1_0", "HTTPv1_1", "HTTPv2_0", "HTTPv2_TLS", and "HTTPv2_PRIOR".
+    # @return [String] the HTTP version for the requests, or "None" if libcurl is to choose permitted versions.
+    # The supported values are the keys of Patron::Request::HTTP_VERSIONS: "None", "HTTPv1_0", "HTTPv1_1",
+    # "HTTPv2_0", "HTTPv2_TLS", "HTTPv2_PRIOR", "HTTPv3" and (with libcurl 7.88+) "HTTPv3_ONLY".
     attr_accessor :http_version
 
     # @return [String] path to the CA file used for certificate verification, or `nil` if CURL default is used
@@ -94,16 +105,15 @@ module Patron
     # response does not specify a charset in it's `Content-Type` header already, if it does that charset
     # will take precedence.
     attr_accessor :default_response_charset
-    
+
     # @return [Boolean] Force curl to use IPv4
     attr_accessor :force_ipv4
 
     # @return [Boolean] Support automatic Content-Encoding decompression and set liberal Accept-Encoding headers
     attr_accessor :automatic_content_encoding
 
-    # @return [Fixnum, nil] the amount of bytes downloaded. If it is set to nil
-    #    (default) no limit will be applied.
-    #    **Note that this only works on libCURL 7.34 and newer**
+    # @return [Integer, nil] the maximum number of bytes to download. If it is set to nil
+    #    (default) no limit will be applied. Exceeding it raises Patron::DownloadLimitExceeded.
     attr_accessor :download_byte_limit
 
     # @return [Integer, nil] the time in number seconds that the transfer speed should be below the
@@ -118,24 +128,20 @@ module Patron
 
     # @return [#call, nil] callable object that will be called with 4 arguments
     #    during request/response execution - `dltotal`, `dlnow`, `ultotal`, `ulnow`.
-    #    All these arguments are in bytes.
+    #    All these arguments are in bytes. Returning `false` from the callback aborts the
+    #    request with Patron::Aborted.
     attr_accessor :progress_callback
 
     # Create a new Session object for performing requests.
     #
-    # @param args[Hash] options for the Session (same names as the writable attributes of the Session)
+    # @param options [Hash] the writable attributes of the Session, by name
     # @yield self
-    def initialize(args = {}, &block)
-
-      # Allows accessors to be set via constructor hash. Ex:  {:base_url => 'www.home.com'}
-      args.each do |attribute, value|
-        send("#{attribute}=", value)
+    def initialize(**options, &block)
+      options.each do |attribute, value|
+        public_send("#{attribute}=", value)
       end
 
-      # Allows accessors to be set via block.
-      if block_given?
-        yield self
-      end
+      yield self if block_given?
 
       @headers ||= {}
       @headers['User-Agent'] ||= Patron.user_agent_string
@@ -156,7 +162,7 @@ module Patron
     def handle_cookies(file_path = nil)
       if file_path
         path = Pathname(file_path).expand_path
-        
+
         if !File.exist?(file_path) && !File.writable?(path.dirname)
           raise ArgumentError, "Can't create file #{path} (permission error)"
         elsif File.exist?(file_path) && !File.writable?(file_path)
@@ -165,22 +171,24 @@ module Patron
       else
         path = nil
       end
-      
-      # Apparently calling this with an empty string sets the cookie file,
-      # but calling it with a path to a writable file sets that file to be
-      # the cookie jar (new cookies are written there)
-      add_cookie_file(path.to_s)
-      
+
+      # libcurl reads the cookie file and, when the path is not empty, also writes the jar back to it
+      @cookie_file_path = path.to_s
+      set_cookie_file(@cookie_file_path)
       self
     end
 
-    # Enable debug output to stderr or to specified `file`.
+    # Enable libcurl's verbose output.
     #
-    # @todo Change to an assignment of an IO object
-    # @param file[String, nil] path to the file to write debug data to, or `nil` to print to `STDERR`
+    # @param destination [IO, String, nil] an IO to write to, a path to a file to write to, or `nil` for `$stderr`
     # @return self
-    def enable_debug(file = nil)
-      set_debug_file(file.to_s)
+    def enable_debug(destination = nil)
+      @debug_io = case destination
+      when nil then $stderr
+      when ->(d) { d.respond_to?(:write) } then destination
+      else File.open(destination.to_s, 'wb').tap { |f| f.sync = true }
+      end
+      set_debug_io(@debug_io)
       self
     end
 
@@ -210,7 +218,7 @@ module Patron
     # @param filename[String] path to the file to save the response body in
     # @return [Patron::Response]
     def get_file(url, filename, headers = {})
-      request(:get, url, headers, :file => filename)
+      request(:get, url, headers, file: filename)
     end
 
     # Same as #get but performs a HEAD request.
@@ -238,7 +246,6 @@ module Patron
     # Uploads the passed `data` to the specified `url` using an HTTP PUT. Note that
     # unline ++post++, a Hash is not accepted as the ++data++ argument.
     #
-    # @todo inconsistency with "post" - Hash not accepted
     # @param url[String] the URL to fetch
     # @param data[#to_s, #to_path] an object that can be converted to a String
     #   to create the request body, or that responds to #to_path to upload the
@@ -246,13 +253,12 @@ module Patron
     # @param headers[Hash] the hash of header keys to values
     # @return [Patron::Response]
     def put(url, data, headers = {})
-      request(:put, url, headers, :data => data)
+      request(:put, url, headers, data: data)
     end
 
     # Uploads the passed `data` to the specified `url` using an HTTP PATCH. Note that
     # unline ++post++, a Hash is not accepted as the ++data++ argument.
     #
-    # @todo inconsistency with "post" - Hash not accepted
     # @param url[String] the URL to fetch
     # @param data[#to_s, #to_path] an object that can be converted to a String
     #   to create the request body, or that responds to #to_path to upload the
@@ -260,7 +266,7 @@ module Patron
     # @param headers[Hash] the hash of header keys to values
     # @return [Patron::Response]
     def patch(url, data, headers = {})
-      request(:patch, url, headers, :data => data)
+      request(:patch, url, headers, data: data)
     end
 
     # Uploads the contents of `file` to the specified `url` using an HTTP PUT. The file will be
@@ -271,7 +277,7 @@ module Patron
     # @param headers[Hash] the hash of header keys to values
     # @return [Patron::Response]
     def put_file(url, filename, headers = {})
-      request(:put, url, headers, :file => filename)
+      request(:put, url, headers, file: filename)
     end
 
     # Uploads the passed `data` to the specified `url` using an HTTP POST.
@@ -285,10 +291,10 @@ module Patron
     # @return [Patron::Response]
     def post(url, data, headers = {})
       if data.is_a?(Hash)
-        data = data.map {|k,v| urlencode(k.to_s) + '=' + urlencode(v.to_s) }.join('&')
-        headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        data = data.map { |k, v| urlencode(k.to_s) + '=' + urlencode(v.to_s) }.join('&')
+        headers = headers.merge('Content-Type' => 'application/x-www-form-urlencoded')
       end
-      request(:post, url, headers, :data => data)
+      request(:post, url, headers, data: data)
     end
 
     # Uploads the contents of `file` to the specified `url` using an HTTP POST.
@@ -299,7 +305,7 @@ module Patron
     # @param headers[Hash] the hash of header keys to values
     # @return [Patron::Response]
     def post_file(url, filename, headers = {})
-      request(:post, url, headers, :file => filename)
+      request(:post, url, headers, file: filename)
     end
 
     # Uploads the contents of `filename` to the specified `url` using an HTTP POST,
@@ -311,7 +317,7 @@ module Patron
     # @param headers[Hash] the hash of header keys to values
     # @return [Patron::Response]
     def post_multipart(url, data, filename, headers = {})
-      request(:post, url, headers, {:data => data, :file => filename, :multipart => true})
+      request(:post, url, headers, data: data, file: filename, multipart: true)
     end
 
     # @!group WebDAV methods
@@ -322,97 +328,97 @@ module Patron
     # @param headers[Hash] the hash of header keys to values
     # @return [Patron::Response]
     def copy(url, dest, headers = {})
-      headers['Destination'] = dest
-      request(:copy, url, headers)
+      request(:copy, url, headers.merge('Destination' => dest))
     end
     # @!endgroup
-    
+
     # @!group Basic API methods
     # Send an HTTP request to the specified `url`.
     #
     # @param action[#to_s] the HTTP verb
     # @param url[String] the URL for the request
     # @param headers[Hash] headers to send along with the request
-    # @param options[Hash] any additonal setters to call on the Request
+    # @param options[Hash] any additional Request attributes, plus `:data`, `:file`, `:multipart` and `:query`
     # @see Patron::Request
     # @return [Patron::Response]
-    def request(action, url, headers, options = {})
-      req = build_request(action, url, headers, options)
-      handle_request(req)
+    def request(action, url, headers = {}, *positional, **options)
+      # The 0.x positional options Hash is tolerated here rather than in a prepended module, since
+      # sniffer and friends alias_method-chain this method and a prepend would recurse into the alias
+      options = Compat.hash_to_keywords("Patron::Session#request with an options Hash", positional, options)
+      handle_request(build_request(action, url, headers, **options))
     end
-    
+
     # Returns the class that will be used to build a Response
     # from a Curl call.
     #
     # Primarily useful if you need a very lightweight Response
     # object that does not have to perform all the parsing of
     # various headers/status codes. The method must return
-    # a module that supports the same interface for +new+
-    # as ++Patron::Response++
+    # a class that supports the same keyword arguments for `new`
+    # as Patron::Response.
     #
-    # @return [#new] Returns any object that responds to `.new` with 6 arguments
+    # @return [#new]
     # @see Patron::Response#initialize
     def response_class
       ::Patron::Response
     end
-    
+
     # Builds a request object that can be used by ++handle_request++
-    # Note that internally, ++handle_request++ uses instance variables of
-    # the Request object, and not it's public methods.
     #
     # @param action[String] the HTTP verb
     # @param url[#to_s] the addition to the base url component, or a complete URL
-    # @param headers[Hash] a hash of headers, "Accept" will be automatically set to an empty string if not provided
+    # @param headers[Hash] a hash of headers, "Expect" will be automatically set to an empty string if not provided
     # @param options[Hash] any overriding options (will shadow the options from the Session object)
     # @return [Patron::Request] the request that will be passed to ++handle_request++
-    def build_request(action, url, headers, options = {})
-      # If the Expect header isn't set uploads are really slow
-      headers['Expect'] ||= ''
-
-      Request.new.tap do |req|
-        req.action                 = action
-        req.headers                = self.headers.merge headers
-        req.automatic_content_encoding = options.fetch :automatic_content_encoding, self.automatic_content_encoding
-        req.timeout                = options.fetch :timeout,               self.timeout
-        req.connect_timeout        = options.fetch :connect_timeout,       self.connect_timeout
-        req.dns_cache_timeout      = options.fetch :dns_cache_timeout,     self.dns_cache_timeout
-        req.low_speed_time         = options.fetch :low_speed_time,        self.low_speed_time
-        req.low_speed_limit        = options.fetch :low_speed_limit,       self.low_speed_limit
-        req.force_ipv4             = options.fetch :force_ipv4,            self.force_ipv4
-        req.max_redirects          = options.fetch :max_redirects,         self.max_redirects
-        req.username               = options.fetch :username,              self.username
-        req.password               = options.fetch :password,              self.password
-        req.proxy                  = options.fetch :proxy,                 self.proxy
-        req.proxy_type             = options.fetch :proxy_type,            self.proxy_type
-        req.auth_type              = options.fetch :auth_type,             self.auth_type
-        req.insecure               = options.fetch :insecure,              self.insecure
-        req.ssl_version            = options.fetch :ssl_version,           self.ssl_version
-        req.http_version           = options.fetch :http_version,          self.http_version
-        req.cacert                 = options.fetch :cacert,                self.cacert
-        req.ssl_cert               = options.fetch :ssl_cert,              self.ssl_cert
-        req.ssl_cert_type          = options.fetch :ssl_cert_type,         self.ssl_cert_type
-        req.ssl_key                = options.fetch :ssl_key,               self.ssl_key
-        req.ssl_key_password       = options.fetch :ssl_key_password,      self.ssl_key_password
-        req.ignore_content_length  = options.fetch :ignore_content_length, self.ignore_content_length
-        req.buffer_size            = options.fetch :buffer_size,           self.buffer_size
-        req.download_byte_limit    = options.fetch :download_byte_limit,   self.download_byte_limit
-        req.progress_callback      = options.fetch :progress_callback,     self.progress_callback
-        req.multipart              = options[:multipart]
-        req.upload_data            = options[:data]
-        req.file_name              = options[:file]
-
-        base_url = self.base_url.to_s
-        url = url.to_s
-        raise ArgumentError, "Empty URL" if base_url.empty? && url.empty?
-        uri = URI.parse(base_url.empty? ? url : File.join(base_url, url))
-        query = uri.query.to_s.split('&')
-        query += options[:query].is_a?(Hash) ? Util.build_query_pairs_from_hash(options[:query]) : options[:query].to_s.split('&')
-        uri.query = query.join('&')
-        uri.query = nil if uri.query.empty?
-        url = uri.to_s
-        req.url = url
-      end
+    def build_request(action, url, headers = {}, **options)
+      # Without an empty Expect header uploads wait for a "100 Continue" that may never come
+      headers = { 'Expect' => '' }.merge(self.headers).merge(headers)
+
+      attributes = REQUEST_ATTRIBUTES_FROM_SESSION.to_h { |name| [name, options.fetch(name) { public_send(name) }] }
+      Request.new(
+        **attributes,
+        action: action,
+        url: build_url(url, options[:query]),
+        headers: headers,
+        multipart: options[:multipart],
+        upload_data: options[:data],
+        file_name: options[:file]
+      )
     end
     # @!endgroup
+
+    private
+
+    REQUEST_ATTRIBUTES_FROM_SESSION = %i[
+      automatic_content_encoding timeout connect_timeout dns_cache_timeout low_speed_time low_speed_limit
+      force_ipv4 max_redirects username password proxy proxy_type auth_type insecure ssl_version http_version
+      cacert ssl_cert ssl_cert_type ssl_key ssl_key_password ignore_content_length buffer_size
+      download_byte_limit progress_callback
+    ].freeze
+    private_constant :REQUEST_ATTRIBUTES_FROM_SESSION
+
+    def build_url(url, query)
+      base_url = self.base_url.to_s
+      url = url.to_s
+      raise ArgumentError, "Empty URL" if base_url.empty? && url.empty?
+
+      full_url = if base_url.empty? || url.match?(%r{\A[a-z][a-z0-9+.-]*://}i)
+        url
+      else
+        "#{base_url.delete_suffix('/')}/#{url.delete_prefix('/')}"
+      end
+
+      uri = URI.parse(full_url)
+      pairs = uri.query.to_s.split('&')
+      pairs += query.is_a?(Hash) ? Util.build_query_pairs_from_hash(query) : query.to_s.split('&')
+      uri.query = pairs.empty? ? nil : pairs.join('&')
+      uri.to_s
+    end
+
+    # Called from the C extension after a fork, when the libcurl handles had to be recreated
+    def reapply_base_options
+      set_cookie_file(@cookie_file_path) if @cookie_file_path
+      set_debug_io(@debug_io) if @debug_io
+    end
   end
 end

data/lib/patron/util.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 module Patron
   module Util
     extend self
-    
-    def build_query_pairs_from_hash(hash, escape_values=false)
-      pairs = []
-      recursive = Proc.new do |h, prefix|
-        h.each_pair do |k,v|
-          key = prefix == '' ? k : "#{prefix}[#{k}]"
+
+    # Flattens a (possibly nested) Hash into "key[sub]=value" pairs, Rack style
+    def build_query_pairs_from_hash(hash, escape_values = false, prefix = nil, pairs = [])
+      hash.each_pair do |k, v|
+        key = prefix ? "#{prefix}[#{k}]" : k.to_s
+        if v.is_a?(Hash)
+          build_query_pairs_from_hash(v, escape_values, key, pairs)
+        else
           v = Patron::Session.escape(v.to_s) if escape_values
-          v.is_a?(Hash) ? recursive.call(v, key) : pairs << "#{key}=#{v}"
+          pairs << "#{key}=#{v}"
         end
       end
-      recursive.call(hash, '')
       pairs
     end
-    
-    def build_query_string_from_hash(hash, escape_values=false)
+
+    def build_query_string_from_hash(hash, escape_values = false)
       build_query_pairs_from_hash(hash, escape_values).join('&')
     end
-    
   end
-end
+end

data/lib/patron/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Patron
-  VERSION = "0.14.0"
+  VERSION = "1.0.0"
 end

data/lib/patron.rb

@@ -1,20 +1,14 @@
-require 'pathname'
+# frozen_string_literal: true
 
-cwd = Pathname(__FILE__).dirname
-$:.unshift(cwd.to_s) unless $:.include?(cwd.to_s) || $:.include?(cwd.expand_path.to_s)
-require 'patron/session'
 require 'patron/version'
+require 'patron/session'
 
 module Patron
-  # Returns the version number of the gem
-  # @return [String]
-  def self.version
-    VERSION
-  end
-  
-  # Returns the default User-Agent string
-  # @return [String]
-  def self.user_agent_string
-    @ua ||= "Patron/Ruby-%s-%s" % [version, libcurl_version]
-  end
+  # @return [String] the version of the gem
+  def self.version = VERSION
+
+  # @return [String] the default User-Agent header value
+  def self.user_agent_string = USER_AGENT_STRING
+
+  USER_AGENT_STRING = "Patron/Ruby-#{VERSION}-#{libcurl_version}".freeze
 end