patron 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e380f44f007f28da3773814cfb58b14feee67d9
-  data.tar.gz: 799cc7f47f3897ea44cf8f843e1608219444f354
+  metadata.gz: 03bffb3257b8f683269cebfec72cc4ea4fd86075
+  data.tar.gz: 2ece06c37c56204f850e138bdf3c481856953dd2
 SHA512:
-  metadata.gz: 8236a3a412232c0bb956476f7031d13ebdfb570a9e583dcf9c064ce2ac7dd83c61a17022c92f0d223baf80e37749d25d1ece6212b39d2ade81c9caf2e552e08a
-  data.tar.gz: 9b7540a564c74bc40116ce2accab42d0bdf48abd428828bdf3d12a3e77a250b781e99f92d63b569b7993be7de4bc4ac9b423d9181b1db4280689cebbe1315377
+  metadata.gz: 7f4a926542616faefd9a2a431d802d8941f99f5eb8c6c592c1ddb1119b30a4000743be8778f62148db4678300265f0283b6b1b927bfa2a8b8dacffb49adc3d2f
+  data.tar.gz: 8f8b71f17282c674149ba146ac32c3e7fb4f954ce44cfa162405b713fe5add7648b1c3d261afb6a5bc58317dbb333049afda93cce6dc8c9023a9256478c0bd4e

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.11.0
+
+* Added `Session#progress_callback` which accepts a callable object, which can be used to report session progress during request
+  execution.
+* Fixed parsing of response headers when multiple responses are involved (redirect chains and HTTP proxies)
+
 ### 0.10.0
 
 * Added `Session#low_speed_time` and `Session#low_speed_limit`. When used, they will force libCURL to raise

data/ext/patron/session_ext.c

@@ -40,7 +40,12 @@ struct patron_curl_state {
   membuffer header_buffer;
   membuffer body_buffer;
   size_t download_byte_limit;
+  VALUE user_progress_blk;
   int interrupt;
+  size_t dltotal;
+  size_t dlnow;
+  size_t ultotal;
+  size_t ulnow;
 };
 
 
@@ -69,16 +74,45 @@ static size_t file_write_handler(void* stream, size_t size, size_t nmemb, FILE*
   }
 }
 
+static int call_user_rb_progress_blk(void* vd_curl_state) {
+  struct patron_curl_state* state = (struct patron_curl_state*)vd_curl_state;
+  // Invoke the block with the array
+  VALUE blk_result = rb_funcall(state->user_progress_blk,
+    rb_intern("call"), 4,
+    LONG2NUM(state->dltotal),
+    LONG2NUM(state->dlnow),
+    LONG2NUM(state->ultotal),
+    LONG2NUM(state->ulnow));
+  return 0;
+}
+
+
 /* A non-zero return value from the progress handler will terminate the current
  * request. We use this fact in order to interrupt any request when either the
  * user calls the "interrupt" method on the session or when the Ruby interpreter
  * is attempting to exit.
  */
-static int session_progress_handler(void *clientp, size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow) {
+static int session_progress_handler(void* clientp, size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow) {
   struct patron_curl_state* state = (struct patron_curl_state*) clientp;
-  UNUSED_ARGUMENT(dlnow);
-  UNUSED_ARGUMENT(ultotal);
-  UNUSED_ARGUMENT(ulnow);
+  state->dltotal = dltotal;
+  state->dlnow = dlnow;
+  state->ultotal = ultotal;
+  state->ulnow = ulnow;
+
+  // If a progress proc has been set, re-acquire the GIL and call it using
+  // `call_user_rb_progress_blk`. TODO: use the retval of that proc
+  // to permit premature abort 
+  if(RTEST(state->user_progress_blk)) {
+    // Even though it is not documented, rb_thread_call_with_gvl is available even when
+    // rb_thread_call_without_gvl is not. See https://bugs.ruby-lang.org/issues/5543#note-4
+    // > rb_thread_call_with_gvl() is globally-visible (but not in headers)
+    // > for 1.9.3: https://bugs.ruby-lang.org/issues/4328
+    #if (defined(HAVE_TBR) || defined(HAVE_TCWOGVL)) && defined(USE_TBR)
+        rb_thread_call_with_gvl((void *(*)(void *)) call_user_rb_progress_blk, (void*)state);
+    #else
+        call_user_rb_progress_blk((void*)state);
+    #endif
+  }
 
   // Set the interrupt if the download byte limit has been reached
   if(state->download_byte_limit != 0 && (dltotal > state->download_byte_limit)) {
@@ -410,6 +444,7 @@ static void set_options_from_request(VALUE self, VALUE request) {
   VALUE action_name           = rb_funcall(request, rb_intern("action"), 0);
   VALUE a_c_encoding          = rb_funcall(request, rb_intern("automatic_content_encoding"), 0);
   VALUE download_byte_limit   = rb_funcall(request, rb_intern("download_byte_limit"), 0);
+  VALUE maybe_progress_proc   = rb_funcall(request, rb_intern("progress_callback"), 0);
 
   if (RTEST(download_byte_limit)) {
     state->download_byte_limit = FIX2INT(download_byte_limit);
@@ -417,6 +452,12 @@ static void set_options_from_request(VALUE self, VALUE request) {
     state->download_byte_limit = 0;
   }
 
+  if (rb_obj_is_proc(maybe_progress_proc)) {
+    state->user_progress_blk = maybe_progress_proc;
+  } else {
+    state->user_progress_blk = Qnil;
+  }
+
   headers = rb_funcall(request, rb_intern("headers"), 0);
   if (RTEST(headers)) {
     if (rb_type(headers) != T_HASH) {
@@ -718,6 +759,17 @@ static VALUE select_error(CURLcode code) {
   return error;
 }
 
+
+/* Uses as the unblocking function when the thread running Patron gets
+   signaled. The important difference with session_interrupt is that we
+   are not allowed to touch any Ruby structures while outside the GIL,
+   but we _are_ permitted to touch our internal curl state struct
+*/
+void session_ubf_abort(void* patron_state) {
+  struct patron_curl_state* state = (struct patron_curl_state*) patron_state;
+  state->interrupt = INTERRUPT_ABORT;
+}
+
 /* Perform the actual HTTP request by calling libcurl. */
 static VALUE perform_request(VALUE self) {
   struct patron_curl_state *state = get_patron_curl_state(self);
@@ -745,17 +797,17 @@ static VALUE perform_request(VALUE self) {
   }
 
 #if (defined(HAVE_TBR) || defined(HAVE_TCWOGVL)) && defined(USE_TBR)
-#if defined(HAVE_TCWOGVL)
-  ret = (CURLcode) rb_thread_call_without_gvl(
-          (void *(*)(void *)) curl_easy_perform, curl,
-          RUBY_UBF_IO, 0
-        );
-#else
-  ret = (CURLcode) rb_thread_blocking_region(
-          (rb_blocking_function_t*) curl_easy_perform, curl,
-          RUBY_UBF_IO, 0
-        );
-#endif
+  #if defined(HAVE_TCWOGVL)
+    ret = (CURLcode) rb_thread_call_without_gvl(
+            (void *(*)(void *)) curl_easy_perform, curl,
+            session_ubf_abort, (void*)state
+          );
+  #else
+    ret = (CURLcode) rb_thread_blocking_region(
+            (rb_blocking_function_t*) curl_easy_perform, curl,
+            session_ubf_abort, (void*)state
+          );
+  #endif
 #else
   ret = curl_easy_perform(curl);
 #endif

data/lib/patron/header_parser.rb

@@ -0,0 +1,32 @@
+module Patron::HeaderParser
+  CRLF = /#{Regexp.escape("\r\n")}/
+
+  # Returned for each response parsed out
+  class SingleResponseHeaders < Struct.new(:status_line, :headers)
+  end
+
+  # Parses a string with lines delimited with CRLF into
+  # an Array of SingleResponseHeaders objects. libCURL supplies
+  # us multiple responses in sequence, so if we encounter multiple redirect
+  # or operate through a proxy - that adds ConnectionEstablished status at
+  # the beginning of the response - we need to account for parsing
+  # multiple response headres and potentially preserving them.
+  #
+  # @param [String] the string of headers, with responses delimited by empty lines. All lines must end with CRLF
+  # @return Array<SingleResponseHeaders>
+  def self.parse(headers_from_multiple_responses_in_sequence)
+    s = StringScanner.new(headers_from_multiple_responses_in_sequence)
+    responses = []
+    until s.eos?
+      return unless scanned = s.scan_until(CRLF)
+      matched_line = scanned[0..-3]
+      if matched_line =~ /^HTTP\/\d\.\d \d+/
+        responses << SingleResponseHeaders.new(matched_line.strip, [])
+      elsif matched_line =~ /^[^:]+\:/
+        raise "Header should follow an HTTP status line" unless responses.any?
+        responses[-1].headers << matched_line
+      end # else it is the end of the headers for the request
+    end
+    responses
+  end
+end

data/lib/patron/request.rb

@@ -25,13 +25,13 @@ module Patron
       :ignore_content_length, :multipart, :action, :timeout, :connect_timeout,
       :max_redirects, :headers, :auth_type, :upload_data, :buffer_size, :cacert,
       :ssl_version, :http_version, :automatic_content_encoding, :force_ipv4, :download_byte_limit,
-      :low_speed_time, :low_speed_limit
+      :low_speed_time, :low_speed_limit, :progress_callback
     ]
 
     WRITER_VARS = [
       :url, :username, :password, :file_name, :proxy, :proxy_type, :insecure,
       :ignore_content_length, :multipart, :cacert, :ssl_version, :http_version, :automatic_content_encoding, :force_ipv4, :download_byte_limit,
-      :low_speed_time, :low_speed_limit
+      :low_speed_time, :low_speed_limit, :progress_callback
     ]
 
     attr_reader *READER_VARS

data/lib/patron/response.rb

@@ -113,16 +113,14 @@ module Patron
     private
 
     # Called by the C code to parse and set the headers
-    def parse_headers(header_data)
+    def parse_headers(header_data_for_multiple_responses)
       @headers = {}
 
-      lines = header_data.split("\r\n")
-
-      @status_line = lines.shift
-
-      lines.each do |line|
-        break if line.empty?
+      responses = Patron::HeaderParser.parse(header_data_for_multiple_responses)
+      last_response = responses[-1] # Only use the last response (for proxies and redirects)
 
+      @status_line = last_response.status_line
+      last_response.headers.each do |line|
         hdr, val = line.split(":", 2)
 
         val.strip! unless val.nil?

data/lib/patron/session.rb

@@ -5,6 +5,7 @@ require 'patron/response_decoding'
 require 'patron/response'
 require 'patron/session_ext'
 require 'patron/util'
+require 'patron/header_parser'
 
 module Patron
 
@@ -101,6 +102,11 @@ module Patron
 
     private :handle_request, :add_cookie_file, :set_debug_file
 
+    # @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.
+    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)
@@ -371,6 +377,7 @@ module Patron
         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]

data/lib/patron/version.rb

@@ -1,3 +1,3 @@
 module Patron
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/spec/header_parser_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Patron::HeaderParser do
+  it 'parses a standard header' do
+    simple_headers_path = File.dirname(__FILE__) + '/sample_response_headers/headers_wetransfer.txt'
+    responses = Patron::HeaderParser.parse(File.read(simple_headers_path))
+
+    expect(responses.length).to eq(1)
+    first_response = responses[0]
+    expect(first_response.status_line).to eq("HTTP/1.1 200 OK")
+    expect(first_response.headers).to be_kind_of(Array)
+    expect(first_response.headers[0]).to eq("Date: Mon, 29 Jan 2018 00:09:09 GMT")
+    expect(first_response.headers[1]).to eq("Content-Type: text/html; charset=utf-8")
+    expect(first_response.headers[2]).to eq("Transfer-Encoding: chunked")
+    expect(first_response.headers[3]).to eq("Connection: keep-alive")
+  end
+
+  it 'parses a sequence of responses resulting from a redirect' do
+    simple_headers_path = File.dirname(__FILE__) + '/sample_response_headers/headers_wetransfer_with_redirect.txt'
+    responses = Patron::HeaderParser.parse(File.read(simple_headers_path))
+
+    expect(responses.length).to eq(2)
+    first_response = responses[0]
+
+    expect(first_response.status_line).to eq("HTTP/1.1 301 Moved Permanently")
+    expect(first_response.headers).to be_kind_of(Array)
+    expect(first_response.headers[0]).to eq("Date: Mon, 29 Jan 2018 00:42:27 GMT")
+    expect(first_response.headers[2]).to eq("Connection: keep-alive")
+    expect(first_response.headers[3]).to eq("Location: https://wetransfer.com/")
+    expect(first_response.headers[4]).to be_nil
+
+    second_response = responses[1]
+    expect(second_response.status_line).to eq("HTTP/1.1 200 OK")
+    expect(second_response.headers).to be_kind_of(Array)
+    expect(second_response.headers[0]).to eq("Date: Mon, 29 Jan 2018 00:42:27 GMT")
+    expect(second_response.headers[1]).to eq("Content-Type: text/html; charset=utf-8")
+    expect(second_response.headers[2]).to eq("Transfer-Encoding: chunked")
+  end
+
+  it 'parses response headers that set cookies' do
+    simple_headers_path = File.dirname(__FILE__) + '/sample_response_headers/headers_with_set_cookie.txt'
+    responses = Patron::HeaderParser.parse(File.read(simple_headers_path))
+
+    expect(responses.length).to eq(1)
+    first_response = responses[0]
+
+    expect(first_response.status_line).to eq("HTTP/1.1 200 OK")
+    expect(first_response.headers).to be_kind_of(Array)
+    expect(first_response.headers[0]).to eq("Content-Type: text/plain")
+    expect(first_response.headers[1]).to start_with('Server:')
+    expect(first_response.headers[2]).to eq("Date: Mon, 29 Jan 2018 01:50:54 GMT")
+    expect(first_response.headers[3]).to eq("Content-Length: 3")
+    expect(first_response.headers[4]).to eq("Connection: Keep-Alive")
+    expect(first_response.headers[5]).to eq("Set-Cookie: a=1")
+  end
+
+  it 'parses response headers with an extra status line from a proxy' do
+    simple_headers_path = File.dirname(__FILE__) + '/sample_response_headers/headers_wetransfer_with_proxy_status.txt'
+    responses = Patron::HeaderParser.parse(File.read(simple_headers_path))
+
+    expect(responses.length).to eq(2)
+    first_response = responses[0]
+
+    expect(first_response.status_line).to eq("HTTP/1.1 200 Connection established")
+    expect(first_response.headers).to be_kind_of(Array)
+    expect(first_response.headers).to be_empty
+
+    second_response = responses[1]
+    expect(second_response.status_line).to eq("HTTP/1.1 200 OK")
+    expect(second_response.headers).to be_kind_of(Array)
+    expect(second_response.headers[0]).to eq("Date: Mon, 29 Jan 2018 00:09:09 GMT")
+  end
+end

data/spec/sample_response_headers/headers_wetransfer.txt

@@ -0,0 +1,18 @@
+HTTP/1.1 200 OK
+Date: Mon, 29 Jan 2018 00:09:09 GMT
+Content-Type: text/html; charset=utf-8
+Transfer-Encoding: chunked
+Connection: keep-alive
+X-Frame-Options: SAMEORIGIN
+X-XSS-Protection: 1; mode=block
+X-Content-Type-Options: nosniff
+Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+Pragma: no-cache
+Expires: Fri, 01 Jan 1990 00:00:00 GMT
+Vary: Accept-Encoding, Origin
+Set-Cookie: _wt_session=BAh7B0kiD3Nlc3Npb25faWQGOgZFVEkiJTllOGNkZDg3N2Y2Mzc2M2E1NWY2NTQwMjYzNzljODJhBjsAVEkiEF9jc3JmX3Rva2VuBjsARkkiMXk4YWtnZDVNYlRYUmJJWkFFaWkzVXFWM3IzbE1aU2xSbFl3SDQ3aHArbU09BjsARg%3D%3D--fe13900e81f693acb4a80d372d864c78704fa776; domain=wetransfer.com; path=/; secure; HttpOnly
+X-Request-Id: 62b0d737-b0f8-400b-ac3a-0f84acf241af
+X-Opaque: dev-1.wt-19171
+X-Runtime: 0.116529
+Strict-Transport-Security: max-age=15552000; includeSubDomains;
+

data/spec/sample_response_headers/headers_wetransfer_with_proxy_status.txt

@@ -0,0 +1,20 @@
+HTTP/1.1 200 Connection established
+
+HTTP/1.1 200 OK
+Date: Mon, 29 Jan 2018 00:09:09 GMT
+Content-Type: text/html; charset=utf-8
+Transfer-Encoding: chunked
+Connection: keep-alive
+X-Frame-Options: SAMEORIGIN
+X-XSS-Protection: 1; mode=block
+X-Content-Type-Options: nosniff
+Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+Pragma: no-cache
+Expires: Fri, 01 Jan 1990 00:00:00 GMT
+Vary: Accept-Encoding, Origin
+Set-Cookie: _wt_session=BAh7B0kiD3Nlc3Npb25faWQGOgZFVEkiJTllOGNkZDg3N2Y2Mzc2M2E1NWY2NTQwMjYzNzljODJhBjsAVEkiEF9jc3JmX3Rva2VuBjsARkkiMXk4YWtnZDVNYlRYUmJJWkFFaWkzVXFWM3IzbE1aU2xSbFl3SDQ3aHArbU09BjsARg%3D%3D--fe13900e81f693acb4a80d372d864c78704fa776; domain=wetransfer.com; path=/; secure; HttpOnly
+X-Request-Id: 62b0d737-b0f8-400b-ac3a-0f84acf241af
+X-Opaque: dev-1.wt-19171
+X-Runtime: 0.116529
+Strict-Transport-Security: max-age=15552000; includeSubDomains;
+

data/spec/sample_response_headers/headers_wetransfer_with_redirect.txt

@@ -0,0 +1,24 @@
+HTTP/1.1 301 Moved Permanently
+Date: Mon, 29 Jan 2018 00:42:27 GMT
+Content-Length: 0
+Connection: keep-alive
+Location: https://wetransfer.com/
+
+HTTP/1.1 200 OK
+Date: Mon, 29 Jan 2018 00:42:27 GMT
+Content-Type: text/html; charset=utf-8
+Transfer-Encoding: chunked
+Connection: keep-alive
+X-Frame-Options: SAMEORIGIN
+X-XSS-Protection: 1; mode=block
+X-Content-Type-Options: nosniff
+Cache-Control: no-cache, no-store, max-age=0, must-revalidate
+Pragma: no-cache
+Expires: Fri, 01 Jan 1990 00:00:00 GMT
+Vary: Accept-Encoding, Origin
+Set-Cookie: _wt_session=BAh7B0kiD3Nlc3Npb25faWQGOgZFVEkiJWYyMGFmZGRlY2QyNDJkNTA3YTc2YmJmYzg2MWNhMGZlBjsAVEkiEF9jc3JmX3Rva2VuBjsARkkiMUkvMUJqR0tCelZxQytKQU1kbDV4ZW5xNDNSaUlDNnVrODhDTEY4Q0dxbXM9BjsARg%3D%3D--b46297a54dd838e0c26b5559314b10deb1f59312; domain=wetransfer.com; path=/; secure; HttpOnly
+X-Request-Id: 09e7a0ef-e9a1-4519-a580-8185e6d64c1c
+X-Opaque: dev-1.wt-24185
+X-Runtime: 0.102958
+Strict-Transport-Security: max-age=15552000; includeSubDomains;
+

data/spec/sample_response_headers/headers_with_set_cookie.txt

@@ -0,0 +1,9 @@
+HTTP/1.1 200 OK 
+Content-Type: text/plain
+Server: WEBrick/1.3.1 (Ruby/2.4.1/2017-03-22) OpenSSL/1.0.2k
+Date: Mon, 29 Jan 2018 01:50:54 GMT
+Content-Length: 3
+Connection: Keep-Alive
+Set-Cookie: a=1
+Set-Cookie: b=2
+

data/spec/session_spec.rb

@@ -178,6 +178,59 @@ describe Patron::Session do
     expect {@session.get("/slow")}.to raise_error(Patron::TimeoutError)
   end
 
+  it "is able to terminate the thread that is running a slow request using Thread#kill (uses the custom unblock)" do
+    t = Thread.new do
+      session = Patron::Session.new
+      session.timeout = 40
+      session.base_url = "http://localhost:9001"
+      session.get("/slow")
+    end
+
+    # Our test server starts sending the body only after 20 seconds. We should be able to abort
+    # using a signal during that time.
+    started = Time.now.to_i
+    sleep 5 # Less than what it takes for the server to respond
+    t.kill # Kill the thread forcibly
+    t.join # wrap up the thread. If Patron is still busy there, this join call will still take 15s.
+
+    delta_s = Time.now.to_i - started
+    expect(delta_s).to be_within(2).of(5)
+  end
+
+  it "is able to terminate the thread that is running a slow request" do
+    t = Thread.new do
+      trap('SIGINT') do
+        exit # exit the thread
+      end
+      session = Patron::Session.new
+      session.timeout = 40
+      session.base_url = "http://localhost:9001"
+      session.get("/slow")
+    end
+
+    # Our test server starts sending the body only after 20 seconds. We should be able to abort
+    # using a signal during that time.
+    started = Time.now.to_i
+    sleep 5 # Less than what it takes for the server to respond
+    Process.kill("INT", Process.pid) # Signal ourselves...
+    t.join # wrap up the thread. If Patron is still busy there, this join call will still take 15s.
+    delta_s = Time.now.to_i - started
+    expect(delta_s).to be_within(2).of(5)
+  end
+
+  it "receives progress callbacks" do
+    session = Patron::Session.new
+    session.timeout = 40
+    session.base_url = "http://localhost:9001"
+    callback_args = []
+    session.progress_callback = Proc.new {|dltotal, dlnow, ultotal, ulnow|
+      callback_args << [dltotal, dlnow, ultotal, ulnow]
+    }
+    session.get("/slow")
+
+    expect(callback_args).not_to be_empty
+  end
+
   it "should follow redirects by default" do
     @session.max_redirects = 1
     response = @session.get("/redirect")
@@ -186,6 +239,12 @@ describe Patron::Session do
     expect(body.path).to be == "/test"
   end
 
+  it "should not keep the Location header from the redirecting response" do
+    @session.max_redirects = 1
+    response = @session.get("/redirect")
+    expect(response.headers['Location']).to be_nil
+  end
+
   it "should include redirect count in response" do
     @session.max_redirects = 1
     response = @session.get("/redirect")

data/spec/support/test_server.rb

@@ -66,8 +66,8 @@ class GzipServlet < HTTPServlet::AbstractServlet
     
     content_length = out.size
     # Content-Length gets set automatically by WEBrick, and if we do it manually
-    # here then two headers will be set.
-    # res.header['Content-Length'] = content_length
+    # here then two headers will be set. This is also against the content encoding
+    # description in the HTTP 1.1 RFC - but hey, Webrick!
     res.header['Content-Encoding'] = 'deflate'
     res.header['Vary'] = 'Accept-Encoding'
     res.body = out.string
@@ -82,9 +82,10 @@ end
 
 class SlowServlet < HTTPServlet::AbstractServlet
   def do_GET(req,res)
-    sleep 3
     res.header['Content-Type'] = 'text/plain'
-    res.body = 'beep'
+    res.body << 'x'
+    sleep 20
+    res.body << 'rest of body'
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patron
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Phillip Toland
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-04 00:00:00.000000000 Z
+date: 2018-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -120,6 +120,7 @@ files:
 - ext/patron/sglib.h
 - lib/patron.rb
 - lib/patron/error.rb
+- lib/patron/header_parser.rb
 - lib/patron/proxy_type.rb
 - lib/patron/request.rb
 - lib/patron/response.rb
@@ -133,9 +134,14 @@ files:
 - script/test_server
 - spec/certs/cacert.pem
 - spec/certs/privkey.pem
+- spec/header_parser_spec.rb
 - spec/patron_spec.rb
 - spec/request_spec.rb
 - spec/response_spec.rb
+- spec/sample_response_headers/headers_wetransfer.txt
+- spec/sample_response_headers/headers_wetransfer_with_proxy_status.txt
+- spec/sample_response_headers/headers_wetransfer_with_redirect.txt
+- spec/sample_response_headers/headers_with_set_cookie.txt
 - spec/session_spec.rb
 - spec/session_ssl_spec.rb
 - spec/spec_helper.rb