marnen-typhoeus 0.3.4

data/CHANGELOG.markdown

@@ -0,0 +1,84 @@
+0.3.3
+--------------
+* Make sure to call the Easy::failure callback on all non-success http response codes, even invalid ones. [balexis]
+* Use bytesize instead of length to determine Content-Length [dlamacchia]
+* Added SSL version option to Easy/Request [michelbarbosa/dbalatero]
+
+0.3.2
+-----
+* Fix array params to be consistent with HTTP spec [gridaphobe]
+* traversal_to_params_hash should use the escape option [itsmeduncan]
+* Fix > 1024 open file descriptors [mschulkind]
+* Fixed a bug with internally queued requests being dropped [mschulkind]
+* Use gemspec in bundler to avoid duplication [mschulkind]
+* Run internally queued requests in FIFO order [mschulkind]
+* Moved Typhoeus::VERSION to a separate file, to fix rake build_native [mschulkind]
+* Fixed problems related to put requests with empty bodies [skaes, GH-84]
+* Added CURLOPT_INTERFACE option via Request#interface=. [spiegela]
+* Added Tempfile support to Form#process! [richievos]
+* Hydra won't forget to accept gzip/deflate encoding [codesnik]
+* Accept and convert strings to integers in Typhoeus::Request#initialize for timeout/cache_timeout/connect_timeout values when using ruby 1.9.x. [djnawara]
+* Added interface for registering stub finders [myronmarston]
+* Fixed header stubbing [myronmarston]
+* Added PKCS12 support [jodell]
+* Make a request with handlers marshallable [bernerdschaefer]
+* Upgraded to RSpec 2 [bernerdschaefer]
+* Fix HTTP status edge-case [balexis]
+* Expose primary_ip to easy object [balexis]
+
+0.2.4
+-----
+* Fix form POSTs to only use multipart for file uploads, otherwise use application/x-www-form-urlencoded [dbalatero]
+
+0.2.3
+-----
+* Code duplication in Typhoeus::Form led to nested URL param errors on POST only. Fixed [dbalatero]
+
+0.2.2
+-----
+* Fixed a problem with nested URL params encoding incorrectly [dbalatero]
+
+0.2.1
+-----
+* Added extended proxy support [Zapotek, GH-46]
+* eliminated compile time warnings by using proper type declarations [skaes, GH-54]
+* fixed broken calls to rb_raise [skaes, GH-54]
+* prevent leaking of curl easy handles when exceptions are raised (either from typhoeus itself or user callbacks) [skaes, GH-54]
+* fixed Easy#timed_out? using curl return codes [skaes, GH-54]
+* provide curl return codes and corresponding curl error messages on classes Easy and Request [skaes, GH-54]
+* allow VCR to whitelist hosts in Typhoeus stubbing/mocking [myronmarston, GH-57]
+* added timed_out? documentation, method to Response [dbalatero, GH-34]
+* added abort to Hydra to prematurely stop a hydra.run [Zapotek]
+* added file upload support for POST requests [jtarchie, GH-59]
+
+0.2.0
+------
+* Fix warning in Request#headers from attr_accessor
+* Params with array values were not parsing into the format that rack expects
+[GH-39, smartocci]
+* Removed Rack as a dependency [GH-45]
+* Added integration hooks for VCR!
+
+0.1.31
+------
+* Fixed bug in setting compression encoding [morhekil]
+* Exposed authentication control methods through Request interface [morhekil]
+
+0.1.30
+-----------
+* Exposed CURLOPT_CONNECTTIMEOUT_MS to Requests [balexis]
+
+0.1.29
+------
+* Fixed a memory corruption with using CURLOPT_POSTFIELDS [gravis,
+32531d0821aecc4]
+
+0.1.28
+----------------
+* Added SSL cert options for Typhoeus::Easy [GH-25, gravis]
+* Ported SSL cert options to Typhoeus::Request interface [gravis]
+* Added support for any HTTP method (purge for Varnish) [ryana]
+
+0.1.27
+------
+* Added rack as dependency, added dev dependencies to Rakefile [GH-21]

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    typhoeus (0.3.3)
+      mime-types
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.7.0)
+    autotest (4.4.6)
+      ZenTest (>= 4.4.1)
+    coderay (0.9.8)
+    diff-lcs (1.1.2)
+    json (1.5.3)
+    method_source (0.6.7)
+      ruby_parser (>= 2.3.1)
+    mime-types (1.18)
+    pry (0.9.7.4)
+      coderay (~> 0.9.8)
+      method_source (~> 0.6.7)
+      ruby_parser (>= 2.3.1)
+      slop (~> 2.1.0)
+    pry-nav (0.0.4)
+      pry (~> 0.9.7.4)
+    rack (1.3.0)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.10)
+    sinatra (1.2.6)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    slop (2.1.0)
+    tilt (1.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  autotest
+  diff-lcs
+  json
+  pry-nav
+  rake
+  rspec (~> 2.6)
+  sinatra
+  typhoeus!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 David Balatero
+
+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.

data/Rakefile

@@ -0,0 +1,43 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+end
+
+task :install do
+  rm_rf "*.gem"
+  puts `gem build typhoeus.gemspec`
+  puts `gem install typhoeus-#{Typhoeus::VERSION}.gem`
+end
+
+desc "Builds the native code"
+task :build_native do
+  system("cd ext/typhoeus && ruby extconf.rb && make clean && make")
+end
+
+desc "Start up the test servers"
+task :start_test_servers do
+  puts "Starting 3 test servers"
+
+  pids = []
+  [3000, 3001, 3002].each do |port|
+    if pid = fork
+      pids << pid
+    else
+      exec('ruby', 'spec/servers/app.rb', '-p', port.to_s)
+    end
+  end
+
+  at_exit do
+    pids.each do |pid|
+      puts "Killing pid #{pid}"
+      Process.kill("KILL", pid)
+    end
+  end
+
+  # Wait for kill.
+  sleep
+end
+
+desc "Build Typhoeus and run all the tests."
+task :default => [:build_native, :spec]

data/ext/typhoeus/.gitignore

@@ -0,0 +1,7 @@
+conftest.dSYM/*
+conftest.dSYM
+mkmf.log
+*.o
+native.bundle
+Makefile
+*.bundle

data/ext/typhoeus/extconf.rb

@@ -0,0 +1,65 @@
+ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
+
+# :stopdoc:
+
+require 'mkmf'
+
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+specified_curl = ARGV[0] =~ /^--with-curl/ ? ARGV[0].split("=")[1] : nil
+LIBDIR = specified_curl ? "#{specified_curl}/lib": Config::CONFIG['libdir']
+INCLUDEDIR = specified_curl ? "#{specified_curl}/include" : Config::CONFIG['includedir']
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'macruby'
+  $LIBRUBYARG_STATIC.gsub!(/-static/, '')
+end
+
+$CFLAGS << " #{ENV["CFLAGS"]}"
+if Config::CONFIG['target_os'] == 'mingw32'
+  $CFLAGS << " -DXP_WIN -DXP_WIN32 -DUSE_INCLUDED_VASPRINTF"
+elsif Config::CONFIG['target_os'] == 'solaris2'
+  $CFLAGS << " -DUSE_INCLUDED_VASPRINTF"
+else
+  $CFLAGS << " -g -DXP_UNIX"
+end
+
+use_macports = !(defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby')
+$LIBPATH << "/opt/local/lib" if use_macports
+
+$CFLAGS << " -O3 -Wall -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline"
+
+if Config::CONFIG['target_os'] == 'mingw32'
+  header = File.join(ROOT, 'cross', 'curl-7.19.4.win32', 'include')
+  unless find_header('curl/curl.h', header)
+    abort "need libcurl"
+  end
+else
+  HEADER_DIRS = [
+    File.join(INCLUDEDIR, "curl"),
+    INCLUDEDIR,
+    '/usr/include/curl',
+    '/usr/local/include/curl'
+  ]
+
+  [
+    '/opt/local/include/curl',
+    '/opt/local/include',
+  ].each { |x| HEADER_DIRS.unshift(x) } if use_macports
+
+  unless find_header('curl/curl.h', *HEADER_DIRS)
+    abort "need libcurl"
+  end
+end
+
+if Config::CONFIG['target_os'] == 'mingw32'
+  find_library('curl', 'curl_easy_init',
+               File.join(ROOT, 'cross', 'curl-7.19.4.win32', 'bin'))
+else
+  find_library('curl', 'curl_easy_init',
+               LIBDIR,
+               '/opt/local/lib',
+               '/usr/local/lib',
+               '/usr/lib'
+    )
+end
+
+create_makefile("typhoeus/native")

data/ext/typhoeus/native.c

@@ -0,0 +1,12 @@
+#include <native.h>
+
+VALUE mTyphoeus;
+
+void Init_native()
+{
+  mTyphoeus = rb_const_get(rb_cObject, rb_intern("Typhoeus"));
+
+  init_typhoeus_easy();
+  init_typhoeus_multi();
+  init_typhoeus_form();
+}

data/ext/typhoeus/native.h

@@ -0,0 +1,22 @@
+#ifndef TYPHOEUS_NATIVE
+#define TYPHOEUS_NATIVE
+
+#include <ruby.h>
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include <curl/multi.h>
+
+void Init_native();
+extern VALUE mTyphoeus;
+extern void init_typhoeus_easy();
+extern void init_typhoeus_multi();
+extern void init_typhoeus_form();
+
+#endif
+
+#ifndef RSTRING_PTR
+
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+
+#endif

data/ext/typhoeus/typhoeus_easy.c

@@ -0,0 +1,232 @@
+#include <typhoeus_easy.h>
+
+static VALUE idAppend;
+VALUE cTyphoeusEasy;
+
+static void dealloc(CurlEasy *curl_easy) {
+  if (curl_easy->request_chunk != NULL) {
+    free(curl_easy->request_chunk);
+  }
+
+  if (curl_easy->headers != NULL) {
+    curl_slist_free_all(curl_easy->headers);
+  }
+
+  curl_easy_cleanup(curl_easy->curl);
+
+  free(curl_easy);
+}
+
+static VALUE easy_setopt_string(VALUE self, VALUE opt_name, VALUE parameter) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  CURLoption opt = NUM2LONG(opt_name);
+  curl_easy_setopt(curl_easy->curl, opt, StringValuePtr(parameter));
+  return opt_name;
+}
+
+static VALUE easy_setopt_form(VALUE self, VALUE opt_name, VALUE parameter) {
+  CurlEasy *curl_easy;
+  CurlForm *curl_form;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+  Data_Get_Struct(parameter, CurlForm, curl_form);
+
+  CURLoption opt = NUM2LONG(opt_name);
+  curl_easy_setopt(curl_easy->curl, opt, curl_form->first);
+  return opt_name;
+}
+
+static VALUE easy_setopt_long(VALUE self, VALUE opt_name, VALUE parameter) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  CURLoption opt = NUM2LONG(opt_name);
+  curl_easy_setopt(curl_easy->curl, opt, NUM2LONG(parameter));
+  return opt_name;
+}
+
+static VALUE easy_getinfo_string(VALUE self, VALUE info) {
+  char *info_string;
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  CURLoption opt = NUM2LONG(info);
+  curl_easy_getinfo(curl_easy->curl, opt, &info_string);
+
+  return rb_str_new2(info_string);
+}
+
+static VALUE easy_getinfo_long(VALUE self, VALUE info) {
+  long info_long;
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  CURLoption opt = NUM2LONG(info);
+  curl_easy_getinfo(curl_easy->curl, opt, &info_long);
+
+  return LONG2NUM(info_long);
+}
+
+static VALUE easy_getinfo_double(VALUE self, VALUE info) {
+  double info_double = 0;
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  CURLoption opt = NUM2LONG(info);
+  curl_easy_getinfo(curl_easy->curl, opt, &info_double);
+
+  return rb_float_new(info_double);
+}
+
+static VALUE easy_perform(VALUE self) {
+  CurlEasy *curl_easy;
+  CURLcode return_code;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+  return_code = curl_easy_perform(curl_easy->curl);
+  rb_iv_set(self, "@curl_return_code", INT2FIX(return_code));
+
+  return Qnil;
+}
+
+static size_t write_data_handler(char *stream, size_t size, size_t nmemb, VALUE val) {
+  long stream_size = (long)(size * nmemb);
+  rb_funcall(val, idAppend, 1, rb_str_new(stream, stream_size));
+  return size * nmemb;
+}
+
+static size_t read_callback(void *ptr, size_t size, size_t nmemb, void *data) {
+  size_t realsize = size * nmemb;
+  RequestChunk *mem = (RequestChunk *)data;
+
+  if (realsize > mem->size - mem->read) {
+    realsize = mem->size - mem->read;
+  }
+
+  if (realsize != 0) {
+    memcpy(ptr, &(mem->memory[mem->read]), realsize);
+    mem->read += realsize;
+  }
+
+  return realsize;
+}
+
+static void set_response_handlers(VALUE easy, CURL *curl) {
+  rb_iv_set(easy, "@response_body", rb_str_new2(""));
+  rb_iv_set(easy, "@response_header", rb_str_new2(""));
+
+  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&write_data_handler);
+  curl_easy_setopt(curl, CURLOPT_WRITEDATA, rb_iv_get(easy, "@response_body"));
+  curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&write_data_handler);
+  curl_easy_setopt(curl, CURLOPT_HEADERDATA, rb_iv_get(easy, "@response_header"));
+}
+
+static VALUE easy_reset(VALUE self) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  if (curl_easy->request_chunk != NULL) {
+    free(curl_easy->request_chunk);
+    curl_easy->request_chunk = NULL;
+  }
+
+  if (curl_easy->headers != NULL) {
+    curl_slist_free_all(curl_easy->headers);
+    curl_easy->headers = NULL;
+  }
+
+  curl_easy_reset(curl_easy->curl);
+
+  set_response_handlers(self, curl_easy->curl);
+
+  return Qnil;
+}
+
+static VALUE easy_add_header(VALUE self, VALUE header) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  curl_easy->headers = curl_slist_append(curl_easy->headers, RSTRING_PTR(header));
+  return header;
+}
+
+static VALUE easy_set_headers(VALUE self) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  curl_easy_setopt(curl_easy->curl, CURLOPT_HTTPHEADER, curl_easy->headers);
+
+  return Qnil;
+}
+
+static VALUE easy_set_request_body(VALUE self, VALUE data, VALUE content_length_header) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  curl_easy->request_chunk = ALLOC(RequestChunk);
+  curl_easy->request_chunk->size = RSTRING_LEN(data);
+  curl_easy->request_chunk->memory = StringValuePtr(data);
+  curl_easy->request_chunk->read = 0;
+
+  curl_easy_setopt(curl_easy->curl, CURLOPT_READFUNCTION, (curl_read_callback)read_callback);
+  curl_easy_setopt(curl_easy->curl, CURLOPT_READDATA, curl_easy->request_chunk);
+  curl_easy_setopt(curl_easy->curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+
+  return Qnil;
+}
+
+static VALUE easy_escape(VALUE self, VALUE data, VALUE length) {
+  CurlEasy *curl_easy;
+  Data_Get_Struct(self, CurlEasy, curl_easy);
+
+  return rb_str_new2(curl_easy_escape(curl_easy->curl, StringValuePtr(data), (int)NUM2INT(length)));
+}
+
+static VALUE version(VALUE self) {
+  return rb_str_new2(curl_version());
+}
+
+static VALUE new(int argc, VALUE *argv, VALUE klass) {
+  CURL *curl = curl_easy_init();
+  CurlEasy *curl_easy = ALLOC(CurlEasy);
+  curl_easy->curl = curl;
+  curl_easy->headers = NULL;
+  curl_easy->request_chunk = NULL;
+  VALUE easy = Data_Wrap_Struct(cTyphoeusEasy, 0, dealloc, curl_easy);
+
+  set_response_handlers(easy, curl);
+
+  rb_obj_call_init(easy, argc, argv);
+
+  return easy;
+}
+
+static VALUE curl_error_message(VALUE self) {
+  VALUE return_code = rb_iv_get(self, "@curl_return_code");
+  if (return_code == Qnil)
+    return Qnil;
+  else {
+    CURLcode rc = (CURLcode)FIX2INT(return_code);
+    return rb_str_new2(curl_easy_strerror(rc));
+  }
+}
+
+void init_typhoeus_easy() {
+  VALUE klass = cTyphoeusEasy = rb_define_class_under(mTyphoeus, "Easy", rb_cObject);
+  idAppend = rb_intern("<<");
+  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_method(klass, "curl_error_message", curl_error_message, 0);
+  rb_define_private_method(klass, "easy_setopt_string", easy_setopt_string, 2);
+  rb_define_private_method(klass, "easy_setopt_form", easy_setopt_form, 2);
+  rb_define_private_method(klass, "easy_setopt_long", easy_setopt_long, 2);
+  rb_define_private_method(klass, "easy_getinfo_string", easy_getinfo_string, 1);
+  rb_define_private_method(klass, "easy_getinfo_long", easy_getinfo_long, 1);
+  rb_define_private_method(klass, "easy_getinfo_double", easy_getinfo_double, 1);
+  rb_define_private_method(klass, "easy_perform", easy_perform, 0);
+  rb_define_private_method(klass, "easy_reset", easy_reset, 0);
+  rb_define_private_method(klass, "easy_set_request_body", easy_set_request_body, 1);
+  rb_define_private_method(klass, "easy_set_headers", easy_set_headers, 0);
+  rb_define_private_method(klass, "easy_add_header", easy_add_header, 1);
+  rb_define_private_method(klass, "easy_escape", easy_escape, 2);
+  rb_define_private_method(klass, "version", version, 0);
+}