RubyGems - ethon - Versions diffs - 0.0.1 - Mend

ethon 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

data/CHANGELOG.md +0 -0
data/Gemfile +6 -0
data/LICENSE +20 -0
data/README.md +85 -0
data/Rakefile +39 -0
data/lib/ethon.rb +18 -0
data/lib/ethon/curl.rb +586 -0
data/lib/ethon/easies/callbacks.rb +80 -0
data/lib/ethon/easies/form.rb +131 -0
data/lib/ethon/easies/header.rb +65 -0
data/lib/ethon/easies/http.rb +43 -0
data/lib/ethon/easies/http/actionable.rb +99 -0
data/lib/ethon/easies/http/delete.rb +23 -0
data/lib/ethon/easies/http/get.rb +22 -0
data/lib/ethon/easies/http/head.rb +22 -0
data/lib/ethon/easies/http/options.rb +22 -0
data/lib/ethon/easies/http/patch.rb +22 -0
data/lib/ethon/easies/http/post.rb +18 -0
data/lib/ethon/easies/http/postable.rb +27 -0
data/lib/ethon/easies/http/put.rb +19 -0
data/lib/ethon/easies/http/putable.rb +22 -0
data/lib/ethon/easies/informations.rb +83 -0
data/lib/ethon/easies/operations.rb +31 -0
data/lib/ethon/easies/options.rb +105 -0
data/lib/ethon/easies/params.rb +54 -0
data/lib/ethon/easies/response_callbacks.rb +25 -0
data/lib/ethon/easies/util.rb +41 -0
data/lib/ethon/easy.rb +104 -0
data/lib/ethon/errors.rb +13 -0
data/lib/ethon/errors/ethon_error.rb +8 -0
data/lib/ethon/errors/multi_add.rb +12 -0
data/lib/ethon/errors/multi_fdset.rb +12 -0
data/lib/ethon/errors/multi_remove.rb +11 -0
data/lib/ethon/errors/multi_timeout.rb +12 -0
data/lib/ethon/errors/select.rb +12 -0
data/lib/ethon/extensions.rb +1 -0
data/lib/ethon/extensions/string.rb +11 -0
data/lib/ethon/multi.rb +47 -0
data/lib/ethon/multies/operations.rb +132 -0
data/lib/ethon/multies/stack.rb +43 -0
data/lib/ethon/version.rb +5 -0
metadata +217 -0

data/CHANGELOG.md ADDED

File without changes

data/Gemfile ADDED

@@ -0,0 +1,6 @@
+source :rubygems
+gemspec
+gem "rake"
+gem "patron"
+gem "curb"

data/LICENSE ADDED

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Hans Hasselberg
+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/README.md ADDED

@@ -0,0 +1,85 @@
+#  Ethon [![Build Status](https://secure.travis-ci.org/typhoeus/ethon.png?branch=master)](http://travis-ci.org/typhoeus/ethon)
+In the greek mythology Ethon is a gigantic eagle the son of Typhoeus and Echidna. So much for the history.
+In the modern world Ethon is a very basic libcurl wrapper using ffi.
+* [Documentation](http://rubydoc.info/github/typhoeus/ethon)
+## Caution
+This is __alpha__!
+## Installation
+With bundler:
+    gem "ethon", :git => "https://github.com/typhoeus/ethon.git", :branch => "master"
+## Usage
+Making the first request is realy simple:
+    easy = Ethon::Easy.new(:url => "www.google.de")
+    easy.prepare
+    easy.perform
+    #=> :ok
+You have access to various options like following redirects:
+    easy = Ethon::Easy.new(:url => "www.google.com", :follow_location => true)
+    easy.prepare
+    easy.perform
+    #=> :ok
+Once you're done you can look at the response code and body:
+    easy = Ethon::Easy.new(:url => "www.google.de")
+    easy.prepare
+    easy.perform
+    easy.response_code
+    #=> 200
+    easy.response_body
+    #=> "<!doctype html><html ..."
+## Http
+In order to make life easier there are some helpers for doing http requests:
+    easy = Ethon::Easy.new
+    easy.http_request("www.google.de", :get, { :params => {:a => 1} })
+    easy.prepare
+    easy.perform
+    #=> :ok
+    easy = Ethon::Easy.new
+    easy.http_request("www.google.de", :post, { :params => { :a => 1 }, :body => { :b => 2 } })
+    easy.prepare
+    easy.perform
+    #=> :ok
+This really handy when doing requests since you don't have to care about setting
+everything up correct.
+##  LICENSE
+(The MIT License)
+Copyright © 2012 [Hans Hasselberg](http://www.hans.io)
+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 ADDED

@@ -0,0 +1,39 @@
+require "bundler"
+Bundler.setup
+require "rake"
+require "rspec/core/rake_task"
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "ethon/version"
+task :gem => :build
+task :build do
+  system "gem build ethon.gemspec"
+end
+task :install => :build do
+  system "gem install ethon-#{Ethon::VERSION}.gem"
+end
+task :release => :build do
+  system "git tag -a v#{Ethon::VERSION} -m 'Tagging #{Ethon::VERSION}'"
+  system "git push --tags"
+  system "gem push ethon-#{Ethon::VERSION}.gem"
+end
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+  t.ruby_opts = "-W -I./spec -rspec_helper"
+end
+desc "Start up the test servers"
+task :start do
+  require 'spec/support/boot'
+  begin
+    Boot.start_servers(:rake)
+  rescue Exception
+  end
+end
+task :default => :spec

data/lib/ethon.rb ADDED

@@ -0,0 +1,18 @@
+require 'ffi'
+require 'rbconfig'
+require 'thread'
+require 'mime/types'
+require 'cgi'
+require 'tempfile'
+require 'ethon/extensions'
+require 'ethon/curl'
+require 'ethon/errors'
+require 'ethon/easy'
+require 'ethon/multi'
+require 'ethon/version'
+# The toplevel namespace which includes everything
+# belonging to ethon.
+module Ethon
+end

data/lib/ethon/curl.rb ADDED

@@ -0,0 +1,586 @@
+module Ethon
+  # :nodoc:
+  module Curl
+    # :nodoc:
+    def Curl.windows?
+      !(RbConfig::CONFIG['host_os'] !~ /mingw|mswin|bccwin/)
+    end
+    extend ::FFI::Library
+    # :nodoc:
+    VERSION_NOW = 3
+    # :nodoc:
+    GLOBAL_SSL     = 0x01
+    # :nodoc:
+    GLOBAL_WIN32   = 0x02
+    # :nodoc:
+    GLOBAL_ALL     = (GLOBAL_SSL | GLOBAL_WIN32)
+    # :nodoc:
+    GLOBAL_DEFAULT = GLOBAL_ALL
+    # :nodoc:
+    EasyCode = enum :easy_code, [
+      :ok,
+      :unsupported_protocol,
+      :failed_init,
+      :url_malformat,
+      :not_built_in,
+      :couldnt_resolve_proxy,
+      :couldnt_resolve_host,
+      :couldnt_connect,
+      :ftp_weird_server_reply,
+      :remote_access_denied,
+      :ftp_accept_failed,
+      :ftp_weird_pass_reply,
+      :ftp_accept_timeout,
+      :ftp_weird_pasv_reply,
+      :ftp_weird_227_format,
+      :ftp_cant_get_host,
+      :obsolete16,
+      :ftp_couldnt_set_type,
+      :partial_file,
+      :ftp_couldnt_retr_file,
+      :obsolete20,
+      :quote_error,
+      :http_returned_error,
+      :write_error,
+      :obsolete24,
+      :upload_failed,
+      :read_error,
+      :out_of_memory,
+      :operation_timedout,
+      :obsolete29,
+      :ftp_port_failed,
+      :ftp_couldnt_use_rest,
+      :obsolete32,
+      :range_error,
+      :http_post_error,
+      :ssl_connect_error,
+      :bad_download_resume,
+      :file_couldnt_read_file,
+      :ldap_cannot_bind,
+      :ldap_search_failed,
+      :obsolete40,
+      :function_not_found,
+      :aborted_by_callback,
+      :bad_function_argument,
+      :obsolete44,
+      :interface_failed,
+      :obsolete46,
+      :too_many_redirects ,
+      :unknown_option,
+      :telnet_option_syntax ,
+      :obsolete50,
+      :peer_failed_verification,
+      :got_nothing,
+      :ssl_engine_notfound,
+      :ssl_engine_setfailed,
+      :send_error,
+      :recv_error,
+      :obsolete57,
+      :ssl_certproblem,
+      :ssl_cipher,
+      :ssl_cacert,
+      :bad_content_encoding,
+      :ldap_invalid_url,
+      :filesize_exceeded,
+      :use_ssl_failed,
+      :send_fail_rewind,
+      :ssl_engine_initfailed,
+      :login_denied,
+      :tftp_notfound,
+      :tftp_perm,
+      :remote_disk_full,
+      :tftp_illegal,
+      :tftp_unknownid,
+      :remote_file_exists,
+      :tftp_nosuchuser,
+      :conv_failed,
+      :conv_reqd,
+      :ssl_cacert_badfile,
+      :remote_file_not_found,
+      :ssh,
+      :ssl_shutdown_failed,
+      :again,
+      :ssl_crl_badfile,
+      :ssl_issuer_error,
+      :ftp_pret_failed,
+      :rtsp_cseq_error,
+      :rtsp_session_error,
+      :ftp_bad_file_list,
+      :chunk_failed,
+      :last]
+    # :nodoc:
+    MultiCode = enum :multi_code, [
+      :call_multi_perform, -1,
+      :ok,
+      :bad_handle,
+      :bad_easy_handle,
+      :out_of_memory,
+      :internal_error,
+      :bad_socket,
+      :unknown_option,
+      :last]
+    # :nodoc:
+    OptionType = enum [
+      :long,           0,
+      :object_point,   10000,
+      :function_point, 20000,
+      :off_t,          30000]
+    # :nodoc:
+    Option = enum :option, [
+      :file,                         OptionType[:object_point]   + 1,
+      :writedata,                    OptionType[:object_point]   + 1,
+      :url,                          OptionType[:object_point]   + 2,
+      :port,                         OptionType[:long]           + 3,
+      :proxy,                        OptionType[:object_point]   + 4,
+      :userpwd,                      OptionType[:object_point]   + 5,
+      :proxyuserpwd,                 OptionType[:object_point]   + 6,
+      :range,                        OptionType[:object_point]   + 7,
+      :infile,                       OptionType[:object_point]   + 9,
+      :readdata,                     OptionType[:object_point]   + 9,
+      :errorbuffer,                  OptionType[:object_point]   + 10,
+      :writefunction,                OptionType[:function_point] + 11,
+      :readfunction,                 OptionType[:function_point] + 12,
+      :timeout,                      OptionType[:long]           + 13,
+      :infilesize,                   OptionType[:long]           + 14,
+      :postfields,                   OptionType[:object_point]   + 15,
+      :referer,                      OptionType[:object_point]   + 16,
+      :ftpport,                      OptionType[:object_point]   + 17,
+      :useragent,                    OptionType[:object_point]   + 18,
+      :low_speed_time,               OptionType[:long]           + 20,
+      :resume_from,                  OptionType[:long]           + 21,
+      :cookie,                       OptionType[:object_point]   + 22,
+      :httpheader,                   OptionType[:object_point]   + 23,
+      :httppost,                     OptionType[:object_point]   + 24,
+      :sslcert,                      OptionType[:object_point]   + 25,
+      :sslcertpasswd,                OptionType[:object_point]   + 26,
+      :sslkeypasswd,                 OptionType[:object_point]   + 26,
+      :crlf,                         OptionType[:long]           + 27,
+      :quote,                        OptionType[:object_point]   + 28,
+      :writeheader,                  OptionType[:object_point]   + 29,
+      :headerdata,                   OptionType[:object_point]   + 29,
+      :cookiefile,                   OptionType[:object_point]   + 31,
+      :sslversion,                   OptionType[:long]           + 32,
+      :timecondition,                OptionType[:long]           + 33,
+      :timevalue,                    OptionType[:long]           + 34,
+      :customrequest,                OptionType[:object_point]   + 36,
+      :stderr,                       OptionType[:object_point]   + 37,
+      :postquote,                    OptionType[:object_point]   + 39,
+      :writeinfo,                    OptionType[:object_point]   + 40,
+      :verbose,                      OptionType[:long]           + 41,
+      :header,                       OptionType[:long]           + 42,
+      :noprogress,                   OptionType[:long]           + 43,
+      :nobody,                       OptionType[:long]           + 44,
+      :failonerror,                  OptionType[:long]           + 45,
+      :upload,                       OptionType[:long]           + 46,
+      :post,                         OptionType[:long]           + 47,
+      :ftplistonly,                  OptionType[:long]           + 48,
+      :ftpappend,                    OptionType[:long]           + 50,
+      :netrc,                        OptionType[:long]           + 51,
+      :followlocation,               OptionType[:long]           + 52,
+      :transfertext,                 OptionType[:long]           + 53,
+      :put,                          OptionType[:long]           + 54,
+      :progressfunction,             OptionType[:function_point] + 56,
+      :progressdata,                 OptionType[:object_point]   + 57,
+      :autoreferer,                  OptionType[:long]           + 58,
+      :proxyport,                    OptionType[:long]           + 59,
+      :postfieldsize,                OptionType[:long]           + 60,
+      :httpproxytunnel,              OptionType[:long]           + 61,
+      :interface,                    OptionType[:object_point]   + 62,
+      :ssl_verifypeer,               OptionType[:long]           + 64,
+      :cainfo,                       OptionType[:object_point]   + 65,
+      :maxredirs,                    OptionType[:long]           + 68,
+      :filetime,                     OptionType[:long]           + 69,
+      :telnetoptions,                OptionType[:object_point]   + 70,
+      :maxconnects,                  OptionType[:long]           + 71,
+      :closepolicy,                  OptionType[:long]           + 72,
+      :fresh_connect,                OptionType[:long]           + 74,
+      :forbid_reuse,                 OptionType[:long]           + 75,
+      :random_file,                  OptionType[:object_point]   + 76,
+      :egdsocket,                    OptionType[:object_point]   + 77,
+      :connecttimeout,               OptionType[:long]           + 78,
+      :headerfunction,               OptionType[:function_point] + 79,
+      :httpget,                      OptionType[:long]           + 80,
+      :ssl_verifyhost,               OptionType[:long]           + 81,
+      :cookiejar,                    OptionType[:object_point]   + 82,
+      :ssl_cipher_list,              OptionType[:object_point]   + 83,
+      :http_version,                 OptionType[:long]           + 84,
+      :ftp_use_epsv,                 OptionType[:long]           + 85,
+      :sslcerttype,                  OptionType[:object_point]   + 86,
+      :sslkey,                       OptionType[:object_point]   + 87,
+      :sslkeytype,                   OptionType[:object_point]   + 88,
+      :sslengine,                    OptionType[:object_point]   + 89,
+      :sslengine_default,            OptionType[:long]           + 90,
+      :dns_use_global_cache,         OptionType[:long]           + 91,
+      :dns_cache_timeout,            OptionType[:long]           + 92,
+      :prequote,                     OptionType[:object_point]   + 93,
+      :debugfunction,                OptionType[:function_point] + 94,
+      :debugdata,                    OptionType[:object_point]   + 95,
+      :cookiesession,                OptionType[:long]           + 96,
+      :capath,                       OptionType[:object_point]   + 97,
+      :buffersize,                   OptionType[:long]           + 98,
+      :nosignal,                     OptionType[:long]           + 99,
+      :share,                        OptionType[:object_point]   + 100,
+      :proxytype,                    OptionType[:long]           + 101,
+      :encoding,                     OptionType[:object_point]   + 102,
+      :private,                      OptionType[:object_point]   + 103,
+      :unrestricted_auth,            OptionType[:long]           + 105,
+      :ftp_use_eprt,                 OptionType[:long]           + 106,
+      :httpauth,                     OptionType[:long]           + 107,
+      :ssl_ctx_function,             OptionType[:function_point] + 108,
+      :ssl_ctx_data,                 OptionType[:object_point]   + 109,
+      :ftp_create_missing_dirs,      OptionType[:long]           + 110,
+      :proxyauth,                    OptionType[:long]           + 111,
+      :ipresolve,                    OptionType[:long]           + 113,
+      :maxfilesize,                  OptionType[:long]           + 114,
+      :infilesize_large,             OptionType[:off_t]          + 115,
+      :resume_from_large,            OptionType[:off_t]          + 116,
+      :maxfilesize_large,            OptionType[:off_t]          + 117,
+      :netrc_file,                   OptionType[:object_point]   + 118,
+      :ftp_ssl,                      OptionType[:long]           + 119,
+      :postfieldsize_large,          OptionType[:off_t]          + 120,
+      :tcp_nodelay,                  OptionType[:long]           + 121,
+      :ftpsslauth,                   OptionType[:long]           + 129,
+      :ioctlfunction,                OptionType[:function_point] + 130,
+      :ioctldata,                    OptionType[:object_point]   + 131,
+      :ftp_account,                  OptionType[:object_point]   + 134,
+      :cookielist,                   OptionType[:object_point]   + 135,
+      :ignore_content_length,        OptionType[:long]           + 136,
+      :ftp_skip_pasv_ip,             OptionType[:long]           + 137,
+      :ftp_filemethod,               OptionType[:long]           + 138,
+      :localport,                    OptionType[:long]           + 139,
+      :localportrange,               OptionType[:long]           + 140,
+      :connect_only,                 OptionType[:long]           + 141,
+      :conv_from_network_function,   OptionType[:function_point] + 142,
+      :conv_to_network_function,     OptionType[:function_point] + 143,
+      :max_send_speed_large,         OptionType[:off_t]          + 145,
+      :max_recv_speed_large,         OptionType[:off_t]          + 146,
+      :ftp_alternative_to_user,      OptionType[:object_point]   + 147,
+      :sockoptfunction,              OptionType[:function_point] + 148,
+      :sockoptdata,                  OptionType[:object_point]   + 149,
+      :ssl_sessionid_cache,          OptionType[:long]           + 150,
+      :ssh_auth_types,               OptionType[:long]           + 151,
+      :ssh_public_keyfile,           OptionType[:object_point]   + 152,
+      :ssh_private_keyfile,          OptionType[:object_point]   + 153,
+      :ftp_ssl_ccc,                  OptionType[:long]           + 154,
+      :timeout_ms,                   OptionType[:long]           + 155,
+      :connecttimeout_ms,            OptionType[:long]           + 156,
+      :http_transfer_decoding,       OptionType[:long]           + 157,
+      :http_content_decoding,        OptionType[:long]           + 158,
+      :copypostfields,               OptionType[:object_point]   + 165]
+    # :nodoc:
+    InfoType = enum [
+      :string, 0x100000,
+      :long,   0x200000,
+      :double, 0x300000,
+      :slist,  0x400000]
+    # :nodoc:
+    Info = enum :info, [
+      :effective_url,           InfoType[:string] + 1,
+      :response_code,           InfoType[:long]   + 2,
+      :total_time,              InfoType[:double] + 3,
+      :namelookup_time,         InfoType[:double] + 4,
+      :connect_time,            InfoType[:double] + 5,
+      :pretransfer_time,        InfoType[:double] + 6,
+      :size_upload,             InfoType[:double] + 7,
+      :size_download,           InfoType[:double] + 8,
+      :speed_download,          InfoType[:double] + 9,
+      :speed_upload,            InfoType[:double] + 10,
+      :header_size,             InfoType[:long]   + 11,
+      :request_size,            InfoType[:long]   + 12,
+      :ssl_verifyresult,        InfoType[:long]   + 13,
+      :filetime,                InfoType[:long]   + 14,
+      :content_length_download, InfoType[:double] + 15,
+      :content_length_upload,   InfoType[:double] + 16,
+      :starttransfer_time,      InfoType[:double] + 17,
+      :content_type,            InfoType[:string] + 18,
+      :redirect_time,           InfoType[:double] + 19,
+      :redirect_count,          InfoType[:long]   + 20,
+      :private,                 InfoType[:string] + 21,
+      :http_connectcode,        InfoType[:long]   + 22,
+      :httpauth_avail,          InfoType[:long]   + 23,
+      :proxyauth_avail,         InfoType[:long]   + 24,
+      :os_errno,                InfoType[:long]   + 25,
+      :num_connects,            InfoType[:long]   + 26,
+      :ssl_engines,             InfoType[:slist]  + 27,
+      :cookielist,              InfoType[:slist]  + 28,
+      :lastsocket,              InfoType[:long]   + 29,
+      :ftp_entry_path,          InfoType[:string] + 30,
+      :redirect_url,            InfoType[:string] + 31,
+      :primary_ip,              InfoType[:string] + 32,
+      :appconnect_time,         InfoType[:double] + 33,
+      :certinfo,                InfoType[:slist]  + 34,
+      :condition_unmet,         InfoType[:long]   + 35,
+      :rtsp_session_id,         InfoType[:string] + 36,
+      :rtsp_client_cseq,        InfoType[:long]   + 37,
+      :rtsp_server_cseq,        InfoType[:long]   + 38,
+      :rtsp_cseq_recv,          InfoType[:long]   + 39,
+      :primary_port,            InfoType[:long]   + 40,
+      :local_ip,                InfoType[:string] + 41,
+      :local_port,              InfoType[:long]   + 42,
+      :last, 42]
+    # :nodoc:
+    FormOption = enum :form_option, [
+      :none,
+      :copyname,
+      :ptrname,
+      :namelength,
+      :copycontents,
+      :ptrcontents,
+      :contentslength,
+      :filecontent,
+      :array,
+      :obsolete,
+      :file,
+      :buffer,
+      :bufferptr,
+      :bufferlength,
+      :contenttype,
+      :contentheader,
+      :filename,
+      :end,
+      :obsolete2,
+      :stream,
+      :last]
+    # :nodoc:
+    Auth = enum [
+      :basic,        0x01,
+      :digest,       0x02,
+      :gssnegotiate, 0x04,
+      :ntlm,         0x08,
+      :digest_ie,    0x10,
+      :auto,         0x1f] # all options or'd together
+    # :nodoc:
+    Proxy = enum [
+      :http,            0,
+      :http_1_0,        1,
+      :socks4,          4,
+      :socks5,          5,
+      :socks4a,         6,
+      :socks5_hostname, 7]
+    # :nodoc:
+    SSLVersion = enum [
+      :default, 0,
+      :tlsv1,   1,
+      :sslv2,   2,
+      :sslv3,   3]
+    # :nodoc:
+    MsgCode = enum :msg_code, [:none, :done, :last]
+    # :nodoc:
+    class MsgData < ::FFI::Union
+      layout :whatever, :pointer,
+             :code, :easy_code
+    end
+    # :nodoc:
+    class Msg < ::FFI::Struct
+      layout :code, :msg_code,
+             :easy_handle, :pointer,
+             :data, MsgData
+    end
+    # :nodoc:
+    class FDSet < ::FFI::Struct
+      # XXX how does this work on non-windows? how can curl know the new size...
+      FD_SETSIZE = 524288 # set a higher maximum number of fds. this has never applied to windows, so just use the default there
+      if Curl.windows?
+        layout :fd_count, :u_int,
+               :fd_array, [:u_int, 64] # 2048 FDs
+        def clear; self[:fd_count] = 0; end
+      else
+        layout :fds_bits, [:long, FD_SETSIZE / ::FFI::Type::LONG.size]
+        # :nodoc:
+        def clear; super; end
+      end
+    end
+    # :nodoc:
+    class Timeval < ::FFI::Struct
+      layout :sec, :time_t,
+             :usec, :suseconds_t
+    end
+    callback :callback, [:pointer, :size_t, :size_t, :pointer], :size_t
+    ffi_lib_flags :now, :global
+    ffi_lib 'libcurl'
+    attach_function :global_init, :curl_global_init, [:long], :int
+    attach_function :easy_init, :curl_easy_init, [], :pointer
+    attach_function :easy_cleanup, :curl_easy_cleanup, [:pointer], :void
+    attach_function :easy_getinfo, :curl_easy_getinfo, [:pointer, :info, :pointer], :easy_code
+    attach_function :easy_setopt, :curl_easy_setopt, [:pointer, :option, :pointer], :easy_code
+    attach_function :easy_setopt_string, :curl_easy_setopt, [:pointer, :option, :string], :easy_code
+    attach_function :easy_setopt_long, :curl_easy_setopt, [:pointer, :option, :long], :easy_code
+    attach_function :easy_setopt_callback, :curl_easy_setopt, [:pointer, :option, :callback], :easy_code
+    attach_function :easy_perform, :curl_easy_perform, [:pointer], :easy_code
+    attach_function :easy_strerror, :curl_easy_strerror, [:int], :string
+    attach_function :easy_escape, :curl_easy_escape, [:pointer, :pointer, :int], :string
+    attach_function :easy_reset, :curl_easy_reset, [:pointer], :void
+    attach_function :formadd, :curl_formadd, [:pointer, :pointer, :varargs], :int
+    attach_function :multi_init, :curl_multi_init, [], :pointer
+    attach_function :multi_add_handle, :curl_multi_add_handle, [:pointer, :pointer], :multi_code
+    attach_function :multi_remove_handle, :curl_multi_remove_handle, [:pointer, :pointer], :multi_code
+    attach_function :multi_info_read, :curl_multi_info_read, [:pointer, :pointer], Msg.ptr
+    attach_function :multi_perform, :curl_multi_perform, [:pointer, :pointer], :multi_code
+    attach_function :multi_timeout, :curl_multi_timeout, [:pointer, :pointer], :multi_code
+    attach_function :multi_fdset, :curl_multi_fdset, [:pointer, FDSet.ptr, FDSet.ptr, FDSet.ptr, :pointer], :multi_code
+    attach_function :multi_strerror, :curl_multi_strerror, [:int], :string
+    attach_function :version, :curl_version, [], :string
+    attach_function :slist_append, :curl_slist_append, [:pointer, :string], :pointer
+    attach_function :slist_free_all, :curl_slist_free_all, [:pointer], :void
+    if windows?
+      ffi_lib 'ws2_32'
+    else
+      ffi_lib ::FFI::Library::LIBC
+    end
+    @blocking = true
+    attach_function :select, [:int, FDSet.ptr, FDSet.ptr, FDSet.ptr, Timeval.ptr], :int
+    @@initialized = false
+    @@init_mutex = Mutex.new
+    class << self
+      # This function sets up the program environment that libcurl needs.
+      # Think of it as an extension of the library loader.
+      #
+      # This function must be called at least once within a program (a program is all the
+      # code that shares a memory space) before the program calls any other function in libcurl.
+      # The environment it sets up is constant for the life of the program and is the same for
+      # every program, so multiple calls have the same effect as one call.
+      #
+      # The flags option is a bit pattern that tells libcurl exactly what features to init,
+      # as described below. Set the desired bits by ORing the values together. In normal
+      # operation, you must specify CURL_GLOBAL_ALL. Don't use any other value unless
+      # you are familiar with it and mean to control internal operations of libcurl.
+      #
+      # This function is not thread safe. You must not call it when any other thread in
+      # the program (i.e. a thread sharing the same memory) is running. This doesn't just
+      # mean no other thread that is using libcurl. Because curl_global_init() calls
+      # functions of other libraries that are similarly thread unsafe, it could conflict with
+      # any other thread that uses these other libraries.
+      def init
+        @@init_mutex.synchronize {
+          if not @@initialized
+            raise RuntimeError.new('curl failed to initialise') if Curl.global_init(GLOBAL_ALL) != 0
+            @@initialized = true
+          end
+        }
+      end
+      # Sets appropriate option for easy, depending on value type.
+      def set_option(option, value, handle)
+        case value
+        when String
+          easy_setopt_string(handle, option, value.to_s)
+        when Integer
+          easy_setopt_long(handle, option, value)
+        when Proc, FFI::Function
+          easy_setopt_callback(handle, option, value)
+        else
+          easy_setopt(handle, option, value) if value
+        end
+      end
+      # Return info as string.
+      #
+      # @example Return info.
+      #   Curl.get_info_string(:primary_ip, easy)
+      #
+      # @param [ Symbol ] option The option name.
+      # @param [ ::FFI::Pointer ] handle The easy handle.
+      #
+      # @return [ String ] The info.
+      def get_info_string(option, handle)
+        if easy_getinfo(handle, option, string_ptr) == :ok
+          string_ptr.read_pointer.read_string
+        else nil
+        end
+      end
+      # Return info as integer.
+      #
+      # @example Return info.
+      #   Curl.get_info_long(:response_code, easy)
+      #
+      # @param [ Symbol ] option The option name.
+      # @param [ ::FFI::Pointer ] handle The easy handle.
+      #
+      # @return [ Integer ] The info.
+      def get_info_long(option, handle)
+        if easy_getinfo(handle, option, long_ptr) == :ok
+          long_ptr.read_long
+        else nil
+        end
+      end
+      # Return info as float.
+      #
+      # @example Return info.
+      #   Curl.get_info_double(:response_code, easy)
+      #
+      # @param [ Symbol ] option The option name.
+      # @param [ ::FFI::Pointer ] handle The easy handle.
+      #
+      # @return [ Float ] The info.
+      def get_info_double(option, handle)
+        if easy_getinfo(handle, option, double_ptr) == :ok
+          double_ptr.read_double
+        else nil
+        end
+      end
+      # Return a string pointer.
+      #
+      # @example Return a string pointer.
+      #   Curl.string_ptr
+      #
+      # @return [ ::FFI::Pointer ] The string pointer.
+      def string_ptr
+        @string_ptr ||= ::FFI::MemoryPointer.new(:pointer)
+      end
+      # Return a long pointer.
+      #
+      # @example Return a long pointer.
+      #   Curl.long_ptr
+      #
+      # @return [ ::FFI::Pointer ] The long pointer.
+      def long_ptr
+        @long_ptr ||= ::FFI::MemoryPointer.new(:long)
+      end
+      # Return a double pointer.
+      #
+      # @example Return a double pointer.
+      #   Curl.double_ptr
+      #
+      # @return [ ::FFI::Pointer ] The double pointer.
+      def double_ptr
+        @double_ptr ||= ::FFI::MemoryPointer.new(:double)
+      end
+    end
+  end
+end