patron 0.4.16 → 0.4.17

data/Gemfile.lock

@@ -6,19 +6,19 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
-    rake (0.8.7)
-    rake-compiler (0.7.5)
+    diff-lcs (1.1.3)
+    rake (0.9.2.2)
+    rake-compiler (0.7.9)
       rake
-    rcov (0.9.9)
-    rspec (2.3.0)
-      rspec-core (~> 2.3.0)
-      rspec-expectations (~> 2.3.0)
-      rspec-mocks (~> 2.3.0)
-    rspec-core (2.3.1)
-    rspec-expectations (2.3.0)
+    rcov (0.9.11)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.3.0)
+    rspec-mocks (2.7.0)
 
 PLATFORMS
   ruby
@@ -26,6 +26,6 @@ PLATFORMS
 DEPENDENCIES
   bundler (>= 1.0.0)
   patron!
-  rake-compiler (~> 0.7.5)
-  rcov (~> 0.9.9)
-  rspec (~> 2.3.0)
+  rake-compiler (>= 0.7.5)
+  rcov (>= 0.9.9)
+  rspec (>= 2.3.0)

data/Rakefile

@@ -35,7 +35,7 @@ end
 
 Bundler::GemHelper.install_tasks
 
-CLEAN.include FileList["ext/patron/*"].exclude(/^.*\.(rb|c)$/)
+CLEAN.include FileList["ext/patron/*"].exclude(/^.*\.(rb|c|h)$/)
 CLOBBER.include %w( doc coverage pkg )
 
 desc "Start an IRB shell"

data/ext/patron/extconf.rb

@@ -40,9 +40,10 @@ elsif !have_library('curl') or !have_header('curl/curl.h')
 end
 
 if CONFIG['CC'] =~ /gcc/
-  $CFLAGS << ' -Wall'
+  $CFLAGS << ' -pedantic -Wall'
 end
 
+$defs.push("-DUSE_TBR")
 $defs.push("-DHAVE_TBR") if have_func('rb_thread_blocking_region')
 
 create_makefile 'patron/session_ext'

data/ext/patron/membuffer.c

@@ -0,0 +1,85 @@
+#include <ruby.h>
+#include <assert.h>
+#include "membuffer.h"
+
+#define DEFAULT_CAPACITY  4096
+#define MAXVAL(a, b) ((a) > (b) ? (a) : (b))
+
+static int membuffer_ensure_capacity( membuffer* m, size_t length ) {
+  size_t new_capacity;
+  char* tmp_buf;
+
+  if (m->capacity >= length) { return MB_OK; }
+
+  new_capacity = MAXVAL(m->capacity, DEFAULT_CAPACITY);
+  while (new_capacity < length) { new_capacity *= 2; }
+
+  tmp_buf = ruby_xrealloc(m->buf, new_capacity+1);
+  if (NULL == tmp_buf) { return MB_OUT_OF_MEMORY; }
+  else {
+    m->buf = tmp_buf;
+    m->capacity = new_capacity;
+  }
+
+  return MB_OK;
+}
+
+void membuffer_init( membuffer* m ) {
+  assert(NULL != m);
+
+  m->buf = NULL;
+  m->length = 0;
+  m->capacity = 0;
+}
+
+void membuffer_destroy( membuffer* m ) {
+  if (NULL == m) { return; }
+
+  if (NULL != m->buf) { ruby_xfree(m->buf); }
+  m->buf = NULL;
+  m->length = 0;
+  m->capacity = 0;
+}
+
+void membuffer_clear( membuffer* m ) {
+  assert(NULL != m);
+
+  if (NULL != m->buf) {
+    memset(m->buf, 0, m->capacity+1);
+    m->length = 0;
+  }
+}
+
+int membuffer_insert( membuffer* m, size_t index, const void* src, size_t length ) {
+  int rc = MB_OK;
+  assert(NULL != m);
+
+  /* sanity checks on the inputs */
+  if (index > m->length) { return MB_OUT_OF_BOUNDS; }
+  if (NULL == src || 0 == length) { return MB_OK; }
+
+  /* increase capacity if needed */
+  rc = membuffer_ensure_capacity( m, m->length + length );
+  if (MB_OK != rc) { return rc; }
+
+  /* move data in the buffer to the right of the insertion point */
+  memmove( m->buf + index + length, m->buf + index, m->length - index );
+
+  /* copy date into the insertion point */
+  memcpy( m->buf + index, src, length );
+  m->length += length;
+  m->buf[m->length] = 0;  /* null terminate the buffer */
+
+  return MB_OK;
+}
+
+int membuffer_append( membuffer* m, const void* src, size_t length ) {
+  assert(NULL != m);
+  return membuffer_insert( m, m->length, src, length );
+}
+
+VALUE membuffer_to_rb_str( membuffer* m ) {
+  assert(NULL != m);
+  return rb_str_new(m->buf, m->length);
+}
+

data/ext/patron/membuffer.h

@@ -0,0 +1,78 @@
+
+#ifndef PATRON_MEMBUFER_H
+#define PATRON_MEMBUFER_H
+
+#include <stdlib.h>
+
+#define MB_OK             0
+#define MB_OUT_OF_MEMORY  1
+#define MB_OUT_OF_BOUNDS  2
+
+/**
+ * Implementation of a simple memory buffer for collecting the response body
+ * and headers from a curl request. The memory buffer will grow to accomodate
+ * the data inserted into it.
+ *
+ * When the memory buffer needs more capacity, it will reallocate memory from
+ * the heap. It will request twice it's current capacity.
+ */
+typedef struct {
+  char    *buf;
+  size_t   length;
+  size_t   capacity;
+} membuffer;
+
+/**
+ * Initialize the memory buffer by setting default values of 0 for the length
+ * and capacity.
+ */
+void membuffer_init( membuffer* m );
+
+/**
+ * Free any memory used by the memory buffer.
+ */
+void membuffer_destroy( membuffer* m );
+
+/**
+ * Clear the contents of the memory buffer. The length will be set to zero,
+ * but the capacity will remain unchanged - i.e. memory will not be freed by
+ * his method.
+ */
+void membuffer_clear( membuffer* m );
+
+/**
+ * Attempt to insert the given _src_ data into the memory buffer at the given
+ * _index_. This method will shift data in the memory buffer to the right in
+ * order to insert the _src_ data.
+ *
+ * This method will fail if the _index_ is out of bounds for the memory
+ * buffer, if the _src_ is NULL or the _length_ to insert is 0. This method
+ * can also fail if the memory buffer needs to expand it's capacity but no
+ * memory is available.
+ *
+ * Return Codes:
+ *   MB_OK
+ *   MB_OUT_OF_MEMORY
+ *   MB_OUT_OF_BOUNDS
+ */
+int membuffer_insert( membuffer* m, size_t index, const void* src, size_t length );
+
+/**
+ * Append the given _src_ data to the end of the memory buffer. This method
+ * calls `membuffer_insert` to append the data.
+ *
+ * Return Codes:
+ *   MB_OK
+ *   MB_OUT_OF_MEMORY
+ */
+int membuffer_append( membuffer* m, const void* src, size_t length );
+
+/**
+ * Convert the memory buffer into a Ruby String instance. This method will
+ * return an empty String instance if the memory buffer is empty. This method
+ * will never return Qnil.
+ */
+VALUE membuffer_to_rb_str( membuffer* m );
+
+#endif
+