patron 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6204d4c97ae0f3c4c096fb8dddef4b7d46a2da8c
-  data.tar.gz: c424a82c114d4720863e0b60563c4fc98f9dcecb
+  metadata.gz: 9e89c04473c18143c350dcbbbf6f98b1c66b2e7e
+  data.tar.gz: 5a019a6f724c14056f949eb4fafb538454b959c6
 SHA512:
-  metadata.gz: 0dcb73a87308df2a7230569762365bfa9da0e76658b1ee5b609c9c0b4dda31aa34e722adba99892ec3dfbd5cc2a58ca45e14882c3c33b495e498f4fe269e1159
-  data.tar.gz: 0a433dfd1c155ae7c05e570052d50ecf9e442c149c66a3e9e9bed1ea1746ee214ce27b31a84f3ea29ccbff8230a46b4272f045ea8038c1ec6e5d229bf7705ad6
+  metadata.gz: 6468281adbd09ad4cbc02eaaa64c36926e108ecd6c9b7a38ffcf8223e5c9930147197c858dac1d30b0f728ece4065f97f32604e07f4016036363b5e110f30ce6
+  data.tar.gz: 897c874cf04b2f3d8fa5e327a5cc78bd86d3ba4a6b27828812c67bc3433cdc0d4c4e6bad266ef655a9349d8f7d711cd95d60bd8c166ede3c8456c788fcc21197

data/.travis.yml

@@ -2,5 +2,6 @@ rvm:
 - 1.9.3
 - 2.1.5
 - 2.2.2
+- 2.3.0
 sudo: false
 cache: bundler

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+### 0.8.0
+
+* Add `Response#inspectable_body`, `Response#decoded_body`. `decoded_body` will atempt to decode
+  the HTTP response into your internal encoding, using the charset header that the server has
+  provided. Note that this operation may fail - if the server said that the body is in a certain
+  encoding, but this is then overridden with, say, `meta` elements in the HTML Patron is _not_
+  going to parse the HTML to figure out how to decode.
+
 ### 0.7.0
 
 * Allow Ruby File objects to be passed as `data` to `Session#put`, `Sesion#post` etc.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    patron (0.7.1)
+    patron (0.8.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/patron/error.rb

@@ -31,29 +31,38 @@ module Patron
 
   # Gets raised when the URL passed to Patron used a protocol that it does not support.
   # This most likely the result of a misspelled protocol string.
-  class UnsupportedProtocol   < Error; end
+  class UnsupportedProtocol    < Error; end
 
   # Gets raised when a request is attempted with an unsupported SSL version.
-  class UnsupportedSSLVersion < Error; end
+  class UnsupportedSSLVersion  < Error; end
 
   # Gets raised when the URL was not properly formatted.
-  class URLFormatError        < Error; end
+  class URLFormatError         < Error; end
 
   # Gets raised when the remote host name could not be resolved.
-  class HostResolutionError   < Error; end
+  class HostResolutionError    < Error; end
 
   # Gets raised when failing to connect to the remote host.
-  class ConnectionFailed      < Error; end
+  class ConnectionFailed       < Error; end
 
   # Gets raised when the response was shorter or larger than expected.
   # This happens when the server first reports an expected transfer size,
   # and then delivers data that doesn't match the previously given size.
-  class PartialFileError      < Error; end
+  class PartialFileError       < Error; end
 
   # Gets raised on an operation timeout. The specified time-out period was reached.
-  class TimeoutError          < Error; end
+  class TimeoutError           < Error; end
 
   # Gets raised on too many redirects. When following redirects, Patron hit the maximum amount.
-  class TooManyRedirects      < Error; end
+  class TooManyRedirects       < Error; end
 
+  # Gets raised when the server specifies an encoding that could not be found, or has an invalid name,
+  # or when the server "lies" about the encoding of the response body (such as can be the case
+  # when the server specifies an encoding in `Content-Type`) which the HTML generator then overrides
+  # with a `meta` element.
+  class HeaderCharsetInvalid < Error; end
+  
+  # Gets raised when you try to use `decoded_body` but it can't
+  # be represented by your Ruby process's current internal encoding
+  class NonRepresentableBody < HeaderCharsetInvalid; end
 end

data/lib/patron/response.rb

@@ -28,6 +28,8 @@ module Patron
 
   # Represents the response from the HTTP server.
   class Response
+    include ResponseDecoding
+    
     # @return [String] the original URL used to perform the request (contains the final URL after redirects)
     attr_reader :url
 
@@ -40,14 +42,16 @@ module Patron
     # @return [Fixnum] how many redirects were followed when fulfilling this request
     attr_reader :redirect_count
 
-    # @return [String, nil] the response body, or nil if the response was written directly to a file
+    # @return [String, nil] the response body as a String encoded as `Encoding::BINARY` or
+    #           or `nil` if the response was written directly to a file
     attr_reader :body
-
+    
     # @return [Hash] the response headers. If there were multiple headers received for the same value
     #   (like "Cookie"), the header values will be within an Array under the key for the header, in order.
     attr_reader :headers
 
-    # @return [String] the recognized name of the charset for the response
+    # @return [String] the recognized name of the charset for the response. The name is not checked
+    #    to be a valid charset name, just stored. To check the charset for validity, use #body_decodable?
     attr_reader :charset
 
     # Overridden so that the output is shorter and there is no response body printed
@@ -56,24 +60,15 @@ module Patron
       "#<Patron::Response @status_line='#{@status_line}'>"
     end
 
-    def initialize(url, status, redirect_count, header_data, body, default_charset = nil)
-      # Don't let a response clear out the default charset, which would cause encoding to fail
-      default_charset = "ASCII-8BIT" unless default_charset
-      @url            = url
+    def initialize(url, status, redirect_count, raw_header_data, body, default_charset = nil)
+      @url            = url.force_encoding(Encoding::ASCII) # the URL is always an ASCII subset, _always_.
       @status         = status
       @redirect_count = redirect_count
-      @body           = body
-
-      @charset        = determine_charset(header_data, body) || default_charset
-
-      [url, header_data].each do |attr|
-        convert_to_default_encoding!(attr)
-      end
+      @body           = body.force_encoding(Encoding::BINARY) if body
 
+      header_data = decode_header_data(raw_header_data)
       parse_headers(header_data)
-      if @headers["Content-Type"] && @headers["Content-Type"][0, 5] == "text/"
-        convert_to_default_encoding!(@body)
-      end
+      @charset = charset_from_content_type
     end
 
     # Tells whether the HTTP response code is less than 400
@@ -90,30 +85,58 @@ module Patron
       status >= 400
     end
     
-    private
-
-    def determine_charset(header_data, body)
-      header_data.match(charset_regex) || (body && body.match(charset_regex))
-
-      charset = $1
-      validate_charset(charset) ? charset : nil
+    # Tells whether the response body can be decoded losslessly into the curren internal encoding
+    #
+    # @return [Boolean] true if the body is decodable, false if otherwise
+    def body_decodable?
+      return true if @body.nil?
+      return true if decoded_body
+    rescue HeaderCharsetInvalid, NonRepresentableBody
+      false
     end
 
-    def charset_regex
-      /(?:charset|encoding)="?([a-z0-9-]+)"?/i
+    # Returns the response body converted into the Ruby process internal encoding (the one set as `Encoding.default_internal`).
+    # As the response gets returned, the response body is not assumed to be in any encoding whatsoever - it will be explicitly
+    # set to `Encoding::BINARY` (as if you were reading a file in binary mode).
+    #
+    # When you call `decoded_body`, the method will
+    # look at the `Content-Type` response header, and check if that header specified a charset. If it did, the method will then
+    # check whether the specified charset is valid (whether it is possible to find a matching `Encoding` class in the VM).
+    # Once that succeeds, the method will check whether the response body _is_ in the encoding that the server said it is.
+    #
+    # This might not be the case - you can, for instance, easily serve an HTML document with a UTF-8 header (with the header
+    # being configured somewhere on the webserver level) and then have the actual HTML document override it with a
+    # `meta` element  or `charset` containing an overriding charset. However, parsing the response body is outside of scope for
+    # Patron, so if this situation happens (the server sets a charset in the header but this header does not match what the server
+    # actually sends in the body) you will get an exception stating this is a problem.
+    #
+    # The next step is actually converting the body to the internal Ruby encoding. That stage may raise an exception as well, if
+    # you are using an internal encoding which can't represent the response body faithfully. For example, if you run Ruby with
+    # a CJK internal encoding, and the response you are trying to decode uses Greek characters and is UTF-8, you are going to
+    # get an exception since it is impossible to coerce those characters to your internal encoding.
+    #
+    # @raise {Patron::HeaderCharsetInvalid} when the server supplied a wrong or incorrect charset, {Patron::NonRepresentableBody}
+    #    when unable to decode the body into the current process encoding.
+    # @return [String, nil]
+    def decoded_body
+      return unless @body
+      @decoded_body ||= decode_body(true)
     end
-
-    def validate_charset(charset)
-      charset && Encoding.find(charset) && true
-    rescue ArgumentError
-      false
+    
+    # Works the same as `decoded_body`, with one substantial difference: characters which can't be represented
+    # in your process' default encoding are going to be replaced with question marks. This can be used for raising
+    # errors when you receive responses which indicate errors on the server you are calling. For example, if you expect
+    # a binary download, and the server sends you an error message and you don't really want to bother figuring out
+    # the encoding it has - but you need to append this response to an error log or similar.
+    #
+    # @see Patron::Response#decoded_body
+    # @return [String, nil]
+    def inspectable_body
+      return unless @body
+      @inspectable_body ||= decode_body(false)
     end
 
-    def convert_to_default_encoding!(str)
-      if str.respond_to?(:encode) && Encoding.default_internal
-        str.force_encoding(charset).encode!(Encoding.default_internal)
-      end
-    end
+    private
 
     # Called by the C code to parse and set the headers
     def parse_headers(header_data)
@@ -138,6 +161,5 @@ module Patron
         end
       end
     end
-
   end
 end

data/lib/patron/response_decoding.rb

@@ -0,0 +1,128 @@
+## -------------------------------------------------------------------
+##
+## Patron HTTP Client: Response class
+## Copyright (c) 2008 The Hive http://www.thehive.com/
+##
+## Permission is hereby granted, free of charge, to any person obtaining a copy
+## of this software and associated documentation files (the "Software"), to deal
+## in the Software without restriction, including without limitation the rights
+## to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+## copies of the Software, and to permit persons to whom the Software is
+## furnished to do so, subject to the following conditions:
+##
+## The above copyright notice and this permission notice shall be included in
+## all copies or substantial portions of the Software.
+##
+## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+## IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+## FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+## AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+## LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+## OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+## THE SOFTWARE.
+##
+## -------------------------------------------------------------------
+
+
+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
+
+    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}
+      end
+  
+      if strict
+        convert_encoding_and_raise(@body)
+      else
+        @body.encode(internal_encoding, :undefined => :replace, :replace => '?')
+      end
+    end
+
+    def convert_encoding_and_raise(str)
+      internal = internal_encoding
+      str.encode(internal)
+    rescue Encoding::UndefinedConversionError => e
+      enc = str.encoding == Encoding::BINARY ? 'binary' : str.encoding.to_s
+      raise NonRepresentableBody,
+        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
+    end
+    
+    def encoding_from_headers_or_binary
+      return Encoding::BINARY unless charset_name = charset_from_content_type
+      Encoding.find(charset_name)
+    rescue ArgumentError => e # invalid charset name
+      raise HeaderCharsetInvalid,
+            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 || ''.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
+      end
+      str # if it doesn't encode, just give back what we got
+    end
+  end
+  
+  private_constant :ResponseDecoding if respond_to?(:private_constant)
+end

data/lib/patron/session.rb

@@ -27,6 +27,7 @@
 require 'uri'
 require 'patron/error'
 require 'patron/request'
+require 'patron/response_decoding'
 require 'patron/response'
 require 'patron/session_ext'
 require 'patron/util'
@@ -347,9 +348,9 @@ module Patron
     # the Request object, and not it's public methods.
     #
     # @param action[String] the HTTP verb
-    # @paran url[#to_s] the addition to the base url component, or a complete URL
-    # @paran headers[Hash] a hash of headers, "Accept" will be automatically set to an empty string if not provided
-    # @paran options[Hash] any overriding options (will shadow the options from the Session object)
+    # @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 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

data/lib/patron/version.rb

@@ -1,3 +1,3 @@
 module Patron
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/spec/response_spec.rb

@@ -32,6 +32,12 @@ require 'base64'
 require 'fileutils'
 
 describe Patron::Response do
+  around(:each) do |example|
+    previous_internal = Encoding.default_internal
+    example.run
+    Encoding.default_internal = previous_internal
+  end
+  
   before(:each) do
     @session = Patron::Session.new
     @session.base_url = "http://localhost:9001"
@@ -75,47 +81,67 @@ describe Patron::Response do
     response = @session.get("/repetitiveheader")
     expect(response.headers['Set-Cookie']).to be == ["a=1","b=2"]
   end
+  
+  describe '#decoded_body and #inspectable_body' do
+    it "should raise with explicitly binary response bodies but allow an inspectable body" do
+      Encoding.default_internal = Encoding::UTF_8
+      response = @session.get("/picture")
+      expect(response.headers['Content-Type']).to be == 'image/png'
+      expect(response.body.encoding).to be == Encoding::BINARY
+      expect(response).not_to be_body_decodable
+      expect {
+        response.decoded_body
+      }.to raise_error(Patron::NonRepresentableBody)
+      
+      inspectable = response.inspectable_body
+      expect(inspectable.encoding).to eq(Encoding::UTF_8)
+      expect(inspectable).to be_valid_encoding
+    end
+    
+    it "should encode body in the internal charset" do
+      allow(Encoding).to receive(:default_internal).and_return("UTF-8")
 
-  it "should works with non-text files" do
-    response = @session.get("/picture")
-    expect(response.headers['Content-Type']).to be == 'image/png'
-    expect(response.body.encoding).to be == Encoding::ASCII_8BIT
-  end
-
-  it "should not allow a default charset to be nil" do
-    allow(Encoding).to receive(:default_internal).and_return("UTF-8")
-    expect {
-      Patron::Response.new("url", "status", 0, "", "", nil)
-    }.to_not raise_error
-  end
-
-  it "should be able to serialize and deserialize itself" do
-    expect(Marshal.load(Marshal.dump(@request))).to eql(@request)
-  end
-
-  it "should encode body in the internal charset" do
-    allow(Encoding).to receive(:default_internal).and_return("UTF-8")
-
-    greek_encoding = Encoding.find("ISO-8859-7")
-    utf_encoding = Encoding.find("UTF-8")
+      greek_encoding = Encoding.find("ISO-8859-7")
+      utf_encoding = Encoding.find("UTF-8")
 
-    headers = "HTTP/1.1 200 OK \r\nContent-Type: text/css\r\n"
-    body = "charset=ISO-8859-7 Ππ".encode(greek_encoding) # Greek alphabet
+      headers = "HTTP/1.1 200 OK \r\nContent-Type: text/css;charset=ISO-8859-7\r\n"
+      body = "Ππ".encode(greek_encoding) # Greek alphabet
 
-    response = Patron::Response.new("url", "status", 0, headers, body, nil)
+      response = Patron::Response.new("url", "status", 0, headers, body, nil)
 
-    expect(response.body.encoding).to eql(utf_encoding)
+      expect(response).to be_body_decodable
+      expect(response.decoded_body.encoding).to eql(utf_encoding)
+    end
+    
+    it "should fallback to default charset when header or body charset is not valid" do
+      allow(Encoding).to receive(:default_internal).and_return("UTF-8")
+
+      encoding = Encoding.find("UTF-8")
+      headers = "HTTP/1.1 200 OK \r\nContent-Type: text/css; charset=invalid\r\n"
+      body = "who knows which encoding this CSS is in?"
+
+      response = Patron::Response.new("url", "status", 0, headers, body, "UTF-8")
+      expect(response.charset).to eq('invalid')
+      
+      expect(response).not_to be_body_decodable
+      expect {
+        response.decoded_body
+      }.to raise_error(Patron::HeaderCharsetInvalid)
+    end
   end
 
-  it "should fallback to default charset when header or body charset is not valid" do
-    allow(Encoding).to receive(:default_internal).and_return("UTF-8")
-
+  it "decodes a header that contains UTF-8 even though internal encoding is ASCII" do
+    Encoding.default_internal = Encoding::ASCII
     encoding = Encoding.find("UTF-8")
-    headers = "HTTP/1.1 200 OK \r\nContent-Type: text/css\r\n"
-    body = "charset=invalid"
+    headers = "HTTP/1.1 200 OK \r\nContent-Disposition: attachment,filename=\"žфайлец.txt\"\r\n"
+    body = "this is a file with a Russian filename set in content-disposition"
 
     response = Patron::Response.new("url", "status", 0, headers, body, "UTF-8")
-
-    expect(response.body.encoding).to eql(encoding)
+    dispo = response.headers['Content-Disposition']
+    expect(dispo.encoding).to eq(Encoding::UTF_8)
+  end
+  
+  it "should be able to serialize and deserialize itself" do
+    expect(Marshal.load(Marshal.dump(@request))).to eql(@request)
   end
 end

data/spec/session_spec.rb

@@ -28,6 +28,7 @@ require 'webrick'
 require 'yaml'
 require 'base64'
 require 'fileutils'
+require 'securerandom'
 
 describe Patron::Session do
 
@@ -233,7 +234,7 @@ describe Patron::Session do
     # but it does get used nevertheless - for instance, it is a usual
     # practice when interacting with an ElasticSearch cluster where
     # you can have very deeply going queries, which are still technically GETs
-    data = SecureRandom.random_bytes(1024 * 24)
+    data = Random.new.bytes(1024 * 24)
     response = @session.request(:get, "/test", {}, :data => data)
     body = YAML::load(response.body)
     expect(body.request_method).to be == "GET"
@@ -241,7 +242,7 @@ describe Patron::Session do
   end
   
   it "should upload data with :put" do
-    data = SecureRandom.random_bytes(1024 * 24)
+    data = Random.new.bytes(1024 * 24)
     response = @session.put("/test", data)
     body = YAML::load(response.body)
     expect(body.request_method).to be == "PUT"
@@ -518,7 +519,7 @@ describe Patron::Session do
     session = Patron::Session.new do |patron|
       patron.timeout = args[:timeout]
       patron.base_url = args[:base_url]
-      patron.headers =  args[:headers]
+      patron.headers = args[:headers]
     end
 
     it 'sets the base_url' do

data/spec/spec_helper.rb

@@ -31,6 +31,7 @@ if ENV["COVERAGE"]
 end
 
 require 'rspec'
+
 # Kill warnings that not raising a specific exception still allows the method
 # to fail with another exception
 RSpec::Expectations.configuration.warn_about_potential_false_positives = false

data/spec/support/test_server.rb

@@ -28,6 +28,7 @@ require 'yaml'
 require 'webrick'
 require 'webrick/https'
 require 'openssl'
+require 'zlib'
 
 include WEBrick
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patron
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Phillip Toland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-11 00:00:00.000000000 Z
+date: 2016-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -92,6 +92,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -109,6 +110,7 @@ files:
 - lib/patron/proxy_type.rb
 - lib/patron/request.rb
 - lib/patron/response.rb
+- lib/patron/response_decoding.rb
 - lib/patron/session.rb
 - lib/patron/util.rb
 - lib/patron/version.rb