patron 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 10e347aa0ab1915c0d428cbfaf4bd6888ae2a9ba
-  data.tar.gz: 76476a77a366bd7b5b2aacc7fe946b26e142b995
+  metadata.gz: c363a7f520fb90344efb2251b25a0dbbc6e0d5db
+  data.tar.gz: f95d681849dd57101b33408327fc3aa38d0dc2e3
 SHA512:
-  metadata.gz: 66045fc85f95a730550b061b255cc1420c4b0e6feee1a5cf5252d5cda68dad5792a146ea290208b683d5fe05c596d767864ef6189cade817c84792b4ae963f47
-  data.tar.gz: c7292c8749d8c70e051b032069fe136e6715c8158c4b8b5a9b9c24967a629aa2314b77ea8e5addca9880163facebe728b255e7a3063a803b8fbc33ee100b2bc6
+  metadata.gz: 1945f68df49b6f96ee53166382807ac5e5a19bd00d2746e325d3af02ffe54b14db6f5ad92a55fe6322f5183b25b047cd2879503b6dfbb5bc9c1afc69c5c617ee
+  data.tar.gz: a487793a4bb938d77804e4f0ea083c61afad062014cacbadcb40343f31ddb3fb55889f844f7b0610101f06f1a765f3c53fe1257bf9b48cabe4fda2ae71398334

data/Gemfile.lock

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

data/ext/patron/session_ext.c

@@ -77,19 +77,6 @@ static size_t session_write_handler(char* stream, size_t size, size_t nmemb, mem
   return size * nmemb;
 }
 
-static size_t session_read_handler(char* stream, size_t size, size_t nmemb, char **buffer) {
-  size_t result = 0;
-
-  if (buffer != NULL && *buffer != NULL) {
-    size_t len = size * nmemb;
-    char *s1 = strncpy(stream, *buffer, len);
-    result = strlen(s1);
-    *buffer += result;
-  }
-
-  return result;
-}
-
 /* 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
@@ -319,6 +306,16 @@ static int formadd_files(VALUE data_key, VALUE data_value, VALUE self) {
   return 0;
 }
 
+// Set the given char pointer and it's length to be the CURL request body
+static void set_curl_request_body(CURL* curl, char* buf, curl_off_t len) {
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, buf);
+  #ifdef CURLOPT_POSTFIELDSIZE_LARGE
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE_LARGE, len);
+  #else
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
+  #endif
+}
+
 static void set_chunked_encoding(struct curl_state *state) {
   state->headers = curl_slist_append(state->headers, "Transfer-Encoding: chunked");
 }
@@ -353,10 +350,10 @@ static void set_options_from_request(VALUE self, VALUE request) {
   VALUE cacert                = Qnil;
   VALUE ssl_version           = Qnil;
   VALUE buffer_size           = Qnil;
-  VALUE action_name           = rb_iv_get(request, "@action");
-  VALUE a_c_encoding          = rb_iv_get(request, "@automatic_content_encoding");
+  VALUE action_name           = rb_funcall(request, rb_intern("action"), 0);
+  VALUE a_c_encoding          = rb_funcall(request, rb_intern("automatic_content_encoding"), 0);
 
-  headers = rb_iv_get(request, "@headers");
+  headers = rb_funcall(request, rb_intern("headers"), 0);
   if (!NIL_P(headers)) {
     if (rb_type(headers) != T_HASH) {
       rb_raise(rb_eArgError, "Headers must be passed in a hash.");
@@ -366,23 +363,20 @@ static void set_options_from_request(VALUE self, VALUE request) {
   }
 
   action = SYM2ID(action_name);
-  if(rb_iv_get(request, "@force_ipv4")) {
+  if(rb_funcall(request, rb_intern("force_ipv4"), 0)) {
     curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
   }
   if (action == rb_intern("get")) {
-    VALUE data = rb_iv_get(request, "@upload_data");
-    VALUE download_file = rb_iv_get(request, "@file_name");
+    VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
+    VALUE download_file = rb_funcall(request, rb_intern("file_name"), 0);
 
     curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
     if (!NIL_P(data)) {
       data = rb_funcall(data, rb_intern("to_s"), 0);
       long len = RSTRING_LEN(data);
       state->upload_buf = StringValuePtr(data);
-      curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+      set_curl_request_body(curl, state->upload_buf, len);
       curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
-      curl_easy_setopt(curl, CURLOPT_READFUNCTION, &session_read_handler);
-      curl_easy_setopt(curl, CURLOPT_READDATA, &state->upload_buf);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, len);
     }
     if (!NIL_P(download_file)) {
       state->download_file = open_file(download_file, "wb");
@@ -390,35 +384,32 @@ static void set_options_from_request(VALUE self, VALUE request) {
     } else {
       state->download_file = NULL;
     }
-  } else if (action == rb_intern("post") || action == rb_intern("put")) {
-    VALUE data = rb_iv_get(request, "@upload_data");
-    VALUE filename = rb_iv_get(request, "@file_name");
-    VALUE multipart = rb_iv_get(request, "@multipart");
-
+  } else if (action == rb_intern("post") || action == rb_intern("put") || action == rb_intern("patch")) {
+    VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
+    VALUE filename = rb_funcall(request, rb_intern("file_name"), 0);
+    VALUE multipart = rb_funcall(request, rb_intern("multipart"), 0);
+
+    if (action == rb_intern("post")) {
+      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
+    } else if (action == rb_intern("put")) {
+      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+    } else if (action == rb_intern("patch")) {
+      curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PATCH");
+    }
+    
     if (!NIL_P(data) && NIL_P(multipart)) {
       data = rb_funcall(data, rb_intern("to_s"), 0);
-      long len = RSTRING_LEN(data);
-      state->upload_buf = StringValuePtr(data);
-
       if (action == rb_intern("post")) {
         curl_easy_setopt(curl, CURLOPT_POST, 1);
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, state->upload_buf);
-        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, len);
-      } else {
-        curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
-        curl_easy_setopt(curl, CURLOPT_READFUNCTION, &session_read_handler);
-        curl_easy_setopt(curl, CURLOPT_READDATA, &state->upload_buf);
-        curl_easy_setopt(curl, CURLOPT_INFILESIZE, len);
       }
+      long len = RSTRING_LEN(data);
+      state->upload_buf = StringValuePtr(data);
+      set_curl_request_body(curl, state->upload_buf, len);
     } else if (!NIL_P(filename) && NIL_P(multipart)) {
       set_chunked_encoding(state);
 
       curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
 
-      if (action == rb_intern("post")) {
-        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
-      }
-
       state->upload_file = open_file(filename, "rb");
       curl_easy_setopt(curl, CURLOPT_READDATA, state->upload_file);
     } else if (!NIL_P(multipart)) {
@@ -441,8 +432,7 @@ static void set_options_from_request(VALUE self, VALUE request) {
 
   // support for data passed with a DELETE request (e.g.: used by elasticsearch)
   } else if (action == rb_intern("delete")) {
-      VALUE data = rb_iv_get(request, "@upload_data");
-
+      VALUE data = rb_funcall(request, rb_intern("upload_data"), 0);
       if (!NIL_P(data)) {
         long len = RSTRING_LEN(data);
         state->upload_buf = StringValuePtr(data);
@@ -475,57 +465,58 @@ static void set_options_from_request(VALUE self, VALUE request) {
     #endif
   }
   
-  url = rb_iv_get(request, "@url");
+  url = rb_funcall(request, rb_intern("url"), 0);
   if (NIL_P(url)) {
     rb_raise(rb_eArgError, "Must provide a URL");
   }
   curl_easy_setopt(curl, CURLOPT_URL, StringValuePtr(url));
 
-  timeout = rb_iv_get(request, "@timeout");
+  timeout = rb_funcall(request, rb_intern("timeout"), 0);
   if (!NIL_P(timeout)) {
     curl_easy_setopt(curl, CURLOPT_TIMEOUT, FIX2INT(timeout));
   }
 
-  timeout = rb_iv_get(request, "@connect_timeout");
+  timeout = rb_funcall(request, rb_intern("connect_timeout"), 0);
   if (!NIL_P(timeout)) {
     curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, FIX2INT(timeout));
   }
 
-  redirects = rb_iv_get(request, "@max_redirects");
+  redirects = rb_funcall(request, rb_intern("max_redirects"), 0);
   if (!NIL_P(redirects)) {
     int r = FIX2INT(redirects);
     curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, r == 0 ? 0 : 1);
     curl_easy_setopt(curl, CURLOPT_MAXREDIRS, r);
   }
 
-  proxy = rb_iv_get(request, "@proxy");
+  proxy = rb_funcall(request, rb_intern("proxy"), 0);
   if (!NIL_P(proxy)) {
     curl_easy_setopt(curl, CURLOPT_PROXY, StringValuePtr(proxy));
   }
 
-  proxy_type = rb_iv_get(request, "@proxy_type");
+  proxy_type = rb_funcall(request, rb_intern("proxy_type"), 0);
   if (!NIL_P(proxy_type)) {
     curl_easy_setopt(curl, CURLOPT_PROXYTYPE, NUM2LONG(proxy_type));
   }
 
   credentials = rb_funcall(request, rb_intern("credentials"), 0);
   if (!NIL_P(credentials)) {
-    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, NUM2LONG(rb_iv_get(request, "@auth_type")));
+    VALUE auth_type = rb_funcall(request, rb_intern("auth_type"), 0);
+    curl_easy_setopt(curl, CURLOPT_HTTPAUTH, NUM2LONG(auth_type));
     curl_easy_setopt(curl, CURLOPT_USERPWD, StringValuePtr(credentials));
   }
 
-  ignore_content_length = rb_iv_get(request, "@ignore_content_length");
+  ignore_content_length = rb_funcall(request, rb_intern("ignore_content_length"), 0);
   if (!NIL_P(ignore_content_length)) {
     curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, 1);
   }
 
-  insecure = rb_iv_get(request, "@insecure");
+  insecure = rb_funcall(request, rb_intern("insecure"), 0);
   if(!NIL_P(insecure)) {
     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
   }
 
-  ssl_version = rb_iv_get(request, "@ssl_version");
+  ssl_version = rb_funcall(request, rb_intern("ssl_version"), 0);
   if(!NIL_P(ssl_version)) {
     VALUE ssl_version_str = rb_funcall(ssl_version, rb_intern("to_s"), 0);
     char* version = StringValuePtr(ssl_version_str);
@@ -540,12 +531,12 @@ static void set_options_from_request(VALUE self, VALUE request) {
     }
   }
 
-  cacert = rb_iv_get(request, "@cacert");
+  cacert = rb_funcall(request, rb_intern("cacert"), 0);
   if(!NIL_P(cacert)) {
     curl_easy_setopt(curl, CURLOPT_CAINFO, StringValuePtr(cacert));
   }
 
-  buffer_size = rb_iv_get(request, "@buffer_size");
+  buffer_size = rb_funcall(request, rb_intern("buffer_size"), 0);
   if (!NIL_P(buffer_size)) {
      curl_easy_setopt(curl, CURLOPT_BUFFERSIZE, NUM2LONG(buffer_size));
   }
@@ -575,7 +566,7 @@ static VALUE create_response(VALUE self, CURL* curl, VALUE header_buffer, VALUE
 
   args[3] = header_buffer;
   args[4] = body_buffer;
-  args[5] = rb_iv_get(self, "@default_response_charset");
+  args[5] = rb_funcall(self, rb_intern("default_response_charset"), 0);
   
   responseKlass = rb_funcall(self, rb_intern("response_class"), 0);
   return rb_class_new_instance(6, args, responseKlass);

data/lib/patron/request.rb

@@ -34,7 +34,7 @@ module Patron
   class Request
 
     # Contains the valid HTTP verbs that can be used to perform requests
-    VALID_ACTIONS = %w[GET PUT POST DELETE HEAD COPY]
+    VALID_ACTIONS = %w[GET PUT POST DELETE HEAD COPY PATCH]
 
     # Initializes a new Request, which defaults to the GET HTTP verb and
     # has it's timeouts set to 0

data/lib/patron/session.rb

@@ -232,6 +232,18 @@ module Patron
       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] an object that can be converted to a String to create the request body
+    # @param headers[Hash] the hash of header keys to values
+    # @return [Patron::Response]
+    def patch(url, data, headers = {})
+      request(:patch, url, headers, :data => data)
+    end
+
     # Uploads the contents of `file` to the specified `url` using an HTTP PUT. The file will be
     # sent "as-is" without any multipart encoding.
     #

data/lib/patron/version.rb

@@ -1,3 +1,3 @@
 module Patron
-  VERSION = "0.6.1"
+  VERSION = "0.6.3"
 end

data/spec/session_spec.rb

@@ -194,14 +194,33 @@ describe Patron::Session do
     expect(body.request_method).to be == "GET"
   end
   
+  it "should upload data with :get" do
+    # Sending a request body with a GET request is a technique seldom used,
+    # 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)
+    response = @session.request(:get, "/test", {}, :data => data)
+    body = YAML::load(response.body)
+    expect(body.request_method).to be == "GET"
+    expect(body.header['content-length']).to be == [data.size.to_s]
+  end
+  
   it "should upload data with :put" do
-    data = "upload data"
+    data = SecureRandom.random_bytes(1024 * 24)
     response = @session.put("/test", data)
     body = YAML::load(response.body)
     expect(body.request_method).to be == "PUT"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
 
+  it "should upload data with :patch" do
+    data = "upload data"
+    response = @session.patch("/testpatch", data)
+    body = YAML::load(response.body)
+    expect(body["body"]).to eq("upload data")
+  end
+
   it "should upload data with :delete" do
     data = "upload data"
     response = @session.request(:delete, "/test", {}, :data => data)
@@ -245,7 +264,7 @@ describe Patron::Session do
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
 
-  it "should post a hash of arguments as a urlencoded form" do
+  it "should POST a hash of arguments as a urlencoded form" do
     data = {:foo => 123, 'baz' => '++hello world++'}
     response = @session.post("/testpost", data)
     body = YAML::load(response.body)

data/spec/support/test_server.rb

@@ -115,6 +115,13 @@ class TestPostBodyServlet < HTTPServlet::AbstractServlet
   end
 end
 
+class TestPatchBodyServlet < HTTPServlet::AbstractServlet
+  include RespondWith
+  def do_PATCH(req, res)
+    respond_with(:PATCH, {'body' => req.body, 'content_type' => req.content_type}, res)
+  end
+end
+
 class SetCookieServlet < HTTPServlet::AbstractServlet
   def do_GET(req, res)
     res['Set-Cookie'] = "session_id=foo123"
@@ -178,6 +185,7 @@ class PatronTestServer
 
     @server.mount("/test", TestServlet)
     @server.mount("/testpost", TestPostBodyServlet)
+    @server.mount("/testpatch", TestPatchBodyServlet)
     @server.mount("/timeout", TimeoutServlet)
     @server.mount("/redirect", RedirectServlet)
     @server.mount("/picture", PictureServlet)
@@ -185,7 +193,6 @@ class PatronTestServer
     @server.mount("/repetitiveheader", RepetitiveHeaderServlet)
     @server.mount("/wrongcontentlength", WrongContentLengthServlet)
     @server.mount("/gzip-compressed", GzipServlet)
-
   end
 
   def start

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patron
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.3
 platform: ruby
 authors:
 - Phillip Toland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-14 00:00:00.000000000 Z
+date: 2016-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler