typhoeus 0.4.2 → 0.5.0.rc

data/lib/typhoeus/easy/callbacks.rb

@@ -1,33 +0,0 @@
-module Typhoeus
-  module EasyFu
-    module Callbacks
-      # gets called when finished and response code is not 2xx,
-      # or curl returns an error code.
-      def success
-        @success.call(self) if @success
-      end
-
-      def on_success(&block)
-        @success = block
-      end
-
-      def on_success=(block)
-        @success = block
-      end
-
-      # gets called when finished and response code is 300-599
-      # or curl returns an error code
-      def failure
-        @failure.call(self) if @failure
-      end
-
-      def on_failure(&block)
-        @failure = block
-      end
-
-      def on_failure=(block)
-        @failure = block
-      end
-    end
-  end
-end

data/lib/typhoeus/easy/ffi_helper.rb

@@ -1,61 +0,0 @@
-module Typhoeus
-  module EasyFu
-    module FFIHelper
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def finalizer(easy)
-          proc {
-            Curl.slist_free_all(easy.header_list) if easy.header_list
-            Curl.easy_cleanup(easy.handle)
-          }
-        end
-      end
-
-      def handle
-        @handle ||= Curl.easy_init
-      end
-
-      def body_write_callback
-        @body_write_callback ||= proc {|stream, size, num, object|
-          response_body << stream.read_string(size * num)
-          size * num
-        }
-      end
-
-      def header_write_callback
-        @header_write_callback ||= proc {|stream, size, num, object|
-          response_header << stream.read_string(size * num)
-          size * num
-        }
-      end
-
-      def read_callback
-        @read_callback ||= proc {|stream, size, num, object|
-          size = size * num
-          left = Utils.bytesize(@request_body) - @request_body_read
-          size = left if size > left
-          if size > 0
-            stream.write_string(Utils.byteslice(@request_body, @request_body_read, size), size)
-            @request_body_read += size
-          end
-          size
-        }
-      end
-
-      def string_ptr
-        @string_ptr ||= ::FFI::MemoryPointer.new(:pointer)
-      end
-
-      def long_ptr
-        @long_ptr ||= ::FFI::MemoryPointer.new(:long)
-      end
-
-      def double_ptr
-        @double_ptr ||= ::FFI::MemoryPointer.new(:double)
-      end
-    end
-  end
-end

data/lib/typhoeus/easy/infos.rb

@@ -1,90 +0,0 @@
-module Typhoeus
-  module EasyFu
-    module Infos
-      def get_info_string(option)
-        if Curl.easy_getinfo(@handle, option, string_ptr) == :ok
-          string_ptr.read_pointer.read_string
-        else nil
-        end
-      end
-
-      def get_info_long(option)
-        if Curl.easy_getinfo(@handle, option, long_ptr) == :ok
-          long_ptr.read_long
-        else nil
-        end
-      end
-
-      def get_info_double(option)
-        if Curl.easy_getinfo(@handle, option, double_ptr) == :ok
-          double_ptr.read_double
-        else nil
-        end
-      end
-
-      def auth_methods
-        get_info_long(:httpauth_avail)
-      end
-
-      def total_time_taken
-        get_info_double(:total_time)
-      end
-
-      def start_transfer_time
-        get_info_double(:starttransfer_time)
-      end
-
-      def app_connect_time
-        get_info_double(:appconnect_time)
-      end
-
-      def pretransfer_time
-        get_info_double(:pretransfer_time)
-      end
-
-      def connect_time
-        get_info_double(:connect_time)
-      end
-
-      def name_lookup_time
-        get_info_double(:namelookup_time)
-      end
-
-      def effective_url
-        get_info_string(:effective_url)
-      end
-
-      def primary_ip
-        get_info_string(:primary_ip)
-      end
-
-      def response_code
-        get_info_long(:response_code)
-      end
-
-      def timed_out?
-        @curl_return_code == :operation_timedout
-      end
-
-      def redirect_count
-        get_info_long(:redirect_count)
-      end
-
-      def curl_return_code
-        Curl::EasyCode[@curl_return_code]
-      end
-
-      def curl_error_message(code = @curl_return_code)
-        code ? Curl.easy_strerror(code) : nil
-      end
-
-      def curl_version
-        Curl.version
-      end
-
-      def supports_zlib?
-        !!(curl_version.match(/zlib/))
-      end
-    end
-  end
-end

data/lib/typhoeus/easy/options.rb

@@ -1,115 +0,0 @@
-module Typhoeus
-  module EasyFu
-    module Options
-      def write_function=(callback)
-        set_option(:writefunction, body_write_callback)
-      end
-
-      def header_function=(callback)
-        set_option(:headerfunction, header_write_callback)
-      end
-
-      def encoding=(encoding)
-        # Enable encoding/compression support
-        set_option(:encoding, encoding)
-      end
-
-      def interface=(interface)
-        @interface = interface
-        set_option(:interface, interface)
-      end
-
-      def verbose=(boolean)
-        set_option(:verbose, !!boolean ? 1 : 0)
-      end
-
-      def follow_location=(boolean)
-        if boolean
-          set_option(:followlocation, 1)
-        else
-          set_option(:followlocation, 0)
-        end
-      end
-
-      def max_redirects=(redirects)
-        set_option(:maxredirs, redirects)
-      end
-
-      def connect_timeout=(milliseconds)
-        @connect_timeout = milliseconds
-        set_option(:nosignal, 1)
-        set_option(:connecttimeout_ms, milliseconds)
-      end
-
-      def timeout=(milliseconds)
-        @timeout = milliseconds
-        set_option(:nosignal, 1)
-        set_option(:timeout_ms, milliseconds)
-      end
-
-      def request_body=(request_body)
-        @request_body = request_body
-        if method == :put
-          @request_body_read = 0
-          set_option(:infilesize, Utils.bytesize(@request_body))
-          set_option(:readfunction, read_callback)
-        else
-          self.post_data = request_body
-        end
-      end
-
-      def user_agent=(user_agent)
-        set_option(:useragent, user_agent)
-      end
-
-      def url=(url)
-        @url = url
-        set_option(:url, url)
-      end
-
-      def method=(method)
-        @method = method
-        if method == :get
-          set_option(:httpget, 1)
-        elsif method == :post
-          set_option(:httppost, 1)
-          self.post_data = ""
-        elsif method == :put
-          set_option(:upload, 1)
-          self.request_body = @request_body.to_s
-        elsif method == :head
-          set_option(:nobody, 1)
-        else
-          set_option(:customrequest, method.to_s.upcase)
-        end
-      end
-
-      def post_data=(data)
-        @post_data_set = true
-        set_option(:postfieldsize, Utils.bytesize(data))
-        set_option(:copypostfields, data)
-      end
-
-      def set_option(option, value)
-        case value
-        when String
-          Curl.easy_setopt_string(handle, option, value.to_s)
-        when Integer
-          Curl.easy_setopt_long(handle, option, value)
-        when Proc, ::FFI::Function
-          Curl.easy_setopt_callback(handle, option, value)
-        when Typhoeus::Form
-          Curl.easy_setopt(handle, option, value.first.read_pointer)
-        else
-          Curl.easy_setopt(handle, option, value) if value
-        end
-      end
-
-      def set_headers
-        @header_list = nil
-        headers.each {|key, value| @header_list = Curl.slist_append(@header_list, "#{key}: #{value}") }
-        set_option(:httpheader, @header_list) unless headers.empty?
-      end
-    end
-  end
-end

data/lib/typhoeus/easy/proxy.rb

@@ -1,20 +0,0 @@
-module Typhoeus
-  module EasyFu
-    module Proxy
-      def proxy=(proxy)
-        set_option(:proxy, proxy[:server])
-        set_option(:proxytype, Typhoeus::Easy::PROXY_TYPES[proxy[:type]]) if proxy[:type]
-      end
-
-      def proxy_auth=(authinfo)
-        set_option(:proxyuserpwd, proxy_credentials(authinfo))
-        set_option(:proxyauth, Typhoeus::Easy::PROXY_TYPES[proxy[:type]]) if authinfo[:method]
-      end
-
-      def proxy_credentials(authinfo)
-        "#{authinfo[:username]}:#{authinfo[:password]}"
-      end
-    end
-  end
-end
-

data/lib/typhoeus/easy/ssl.rb

@@ -1,82 +0,0 @@
-module Typhoeus
-  module EasyFu
-    module SSL
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def valid_ssl_version(version)
-          Typhoeus::Easy::SSL_VERSIONS.key?(version.to_sym)
-        end
-      end
-
-      def ssl_version
-        @ssl_version
-      end
-
-      def ssl_version=(version)
-        raise "Invalid SSL version: '#{version}' supplied! Please supply one as listed in Typhoeus::Easy::SSL_VERSIONS" unless self.class.valid_ssl_version(version)
-        @ssl_version = version
-
-        set_option(:sslversion, Typhoeus::Easy::SSL_VERSIONS[version])
-      end
-
-      def disable_ssl_peer_verification
-        set_option(:ssl_verifypeer, 0)
-      end
-
-      def disable_ssl_host_verification
-        set_option(:ssl_verifyhost, 0)
-      end
-
-      # Set SSL certificate
-      # " The string should be the file name of your certificate. "
-      # The default format is "PEM" and can be changed with ssl_cert_type=
-      def ssl_cert=(cert)
-        set_option(:sslcert, cert)
-      end
-
-      # Set SSL certificate type
-      # " The string should be the format of your certificate. Supported formats are "PEM" and "DER" "
-      def ssl_cert_type=(cert_type)
-        raise "Invalid ssl cert type : '#{cert_type}'..." if cert_type and !%w(PEM DER p12).include?(cert_type)
-        set_option(:sslcerttype, cert_type)
-      end
-
-      # Set SSL Key file
-      # " The string should be the file name of your private key. "
-      # The default format is "PEM" and can be changed with ssl_key_type=
-      #
-      def ssl_key=(key)
-        set_option(:sslkey, key)
-      end
-
-      # Set SSL Key type
-      # " The string should be the format of your private key. Supported formats are "PEM", "DER" and "ENG". "
-      #
-      def ssl_key_type=(key_type)
-        raise "Invalid ssl key type : '#{key_type}'..." if key_type and !%w(PEM DER ENG).include?(key_type)
-        set_option(:sslkeytype, key_type)
-      end
-
-      def ssl_key_password=(key_password)
-        set_option(:keypasswd, key_password)
-      end
-
-      # Set SSL CACERT
-      # " File holding one or more certificates to verify the peer with. "
-      #
-      def ssl_cacert=(cacert)
-        set_option(:cainfo, cacert)
-      end
-
-      # Set CAPATH
-      # " directory holding multiple CA certificates to verify the peer with. The certificate directory must be prepared using the openssl c_rehash utility. "
-      #
-      def ssl_capath=(capath)
-        set_option(:capath, capath)
-      end
-    end
-  end
-end

data/lib/typhoeus/easy.rb

@@ -1,115 +0,0 @@
-require 'typhoeus/easy/ffi_helper'
-require 'typhoeus/easy/options'
-require 'typhoeus/easy/ssl'
-require 'typhoeus/easy/auth'
-require 'typhoeus/easy/proxy'
-require 'typhoeus/easy/callbacks'
-require 'typhoeus/easy/infos'
-
-module Typhoeus
-  class Easy
-    include Typhoeus::EasyFu::FFIHelper
-    include Typhoeus::EasyFu::Options
-    include Typhoeus::EasyFu::SSL
-    include Typhoeus::EasyFu::Auth
-    include Typhoeus::EasyFu::Proxy
-    include Typhoeus::EasyFu::Callbacks
-    include Typhoeus::EasyFu::Infos
-
-    OPTION_VALUES = Curl::Option.to_hash.dup
-    Curl::Option.to_hash.each {|key, value| OPTION_VALUES["CURLOPT_#{key.to_s.upcase}".to_sym] = value }
-    INFO_VALUES = Curl::Info.to_hash.dup
-    Curl::Info.to_hash.each {|key, value| INFO_VALUES["CURLINFO_#{key.to_s.upcase}".to_sym] = value }
-    AUTH_TYPES = Curl::Auth.to_hash.dup
-    Curl::Auth.to_hash.each {|key, value| AUTH_TYPES["CURLAUTH_#{key.to_s.upcase}".to_sym] = value }
-    PROXY_TYPES = Curl::Proxy.to_hash.dup
-    Curl::Proxy.to_hash.each {|key, value| PROXY_TYPES["CURLPROXY_#{key.to_s.upcase}".to_sym] = value }
-    SSL_VERSIONS = Curl::SSLVersion.to_hash.dup
-    Curl::SSLVersion.to_hash.each {|key, value| SSL_VERSIONS["CURL_SSLVERSION_#{key.to_s.upcase}".to_sym] = value }
-
-    attr_reader :url, :header_list
-    attr_accessor :start_time
-
-    def initialize
-      Curl.init
-      reset(true)
-      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
-    end
-
-    def method
-      @method ||= :get
-    end
-
-    def headers
-      @headers ||= {}
-    end
-
-    def response_body
-      @response_body ||= ""
-    end
-
-    def response_header
-      @response_header ||= ""
-    end
-
-    def headers=(hash)
-      @headers = hash
-    end
-
-    def params
-      @form.nil? ? {} : @form.params
-    end
-
-    def params=(params)
-      @form = Typhoeus::Form.new(params)
-
-      if method == :post
-        @form.process!
-        if @form.multipart?
-          set_option(:httppost, @form)
-        else
-          self.post_data = @form.to_s
-        end
-      else
-        self.url = "#{url}?#{@form.to_s}"
-      end
-    end
-
-    def perform
-      set_headers()
-      @curl_return_code = Curl.easy_perform(handle)
-      resp_code = response_code()
-      if resp_code >= 200 && resp_code <= 299
-        success
-      else
-        failure
-      end
-      resp_code
-    end
-
-    def reset(fresh = nil)
-      unless fresh
-        @response_code = 0
-        @response_header = ""
-        @response_body = ""
-        @request_body = ""
-
-        if @header_list
-          Curl.slist_free_all(@header_list)
-          @header_list = nil
-        end
-
-        Curl.easy_reset(handle)
-      end
-
-      self.write_function = body_write_callback
-      self.header_function = header_write_callback
-      self.encoding = ''
-      self.ssl_version = :default
-    end
-
-    def curl_return_code=(code)
-      @curl_return_code = (code.class == Symbol ? code : Curl::EasyCode[code])
-    end
-  end
-end

data/lib/typhoeus/filter.rb

@@ -1,28 +0,0 @@
-module Typhoeus
-  class Filter
-    attr_reader :method_name
-    
-    def initialize(method_name, options = {})
-      @method_name = method_name
-      @options = options
-    end
-    
-    def apply_filter?(method_name)
-      if @options[:only]
-        if @options[:only].instance_of? Symbol
-          @options[:only] == method_name
-        else
-          @options[:only].include?(method_name)
-        end
-      elsif @options[:except]
-        if @options[:except].instance_of? Symbol
-          @options[:except] != method_name
-        else
-          !@options[:except].include?(method_name)
-        end
-      else
-        true
-      end
-    end
-  end
-end

data/lib/typhoeus/form.rb

@@ -1,61 +0,0 @@
-require 'mime/types'
-
-module Typhoeus
-  class Form
-    attr_accessor :params
-    attr_reader :first, :traversal
-
-    def initialize(params = {})
-      @params = params
-      @first = ::FFI::MemoryPointer.new(:pointer)
-      @last = ::FFI::MemoryPointer.new(:pointer)
-
-      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
-    end
-
-    def self.finalizer(form)
-      proc { Curl.formfree(form.first) }
-    end
-
-    def traversal
-      @traversal ||= Typhoeus::Utils.traverse_params_hash(params)
-    end
-
-    def formadd_param(name, contents)
-      Curl.formadd(@first, @last,
-        :form_option, :copyname, :pointer, name,
-        :form_option, :namelength, :long, Utils.bytesize(name),
-        :form_option, :copycontents, :pointer, contents,
-        :form_option, :contentslength, :long, Utils.bytesize(contents),
-        :form_option, :end)
-    end
-    private :formadd_param
-
-    def formadd_file(name, filename, contenttype, file)
-      Curl.formadd(@first, @last,
-        :form_option, :copyname, :pointer, name,
-        :form_option, :namelength, :long, Utils.bytesize(name),
-        :form_option, :file, :string, file,
-        :form_option, :filename, :string, filename,
-        :form_option, :contenttype, :string, contenttype,
-        :form_option, :end)
-    end
-    private :formadd_file
-
-    def process!
-      # add params
-      traversal[:params].each { |p| formadd_param(p[0], p[1]) }
-
-      # add files
-      traversal[:files].each { |file_args| formadd_file(*file_args) }
-    end
-
-    def multipart?
-      !traversal[:files].empty?
-    end
-
-    def to_s
-      Typhoeus::Utils.traversal_to_param_string(traversal, false)
-    end
-  end
-end

data/lib/typhoeus/header.rb

@@ -1,54 +0,0 @@
-module Typhoeus
-  class Header < ::Hash
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    def [](key)
-      super(convert_key(key))
-    end
-
-    def []=(key, value)
-      super(convert_key(key), value)
-    end
-
-    def update(other_hash)
-      other_hash.each_pair do |key, value|
-        self[convert_key(key)] = value
-      end
-      self
-    end
-
-    alias_method :merge!, :update
-
-    def dup
-      self.class.new(Marshal.load(Marshal.dump(self)))
-    end
-
-    def merge(hash)
-      self.dup.update(hash)
-    end
-
-    def delete(key)
-      super(convert_key(key))
-    end
-
-  private
-    def convert_key(key)
-      key.to_s.split(/_|-/).map { |segment| segment.capitalize }.join("-")
-    end
-  end
-end

data/lib/typhoeus/hydra/callbacks.rb

@@ -1,24 +0,0 @@
-module Typhoeus
-  class Hydra
-    module Callbacks
-      def self.extended(base)
-        class << base
-          attr_accessor :global_hooks
-        end
-        base.global_hooks = Hash.new { |h, k| h[k] = [] }
-      end
-
-      def after_request_before_on_complete(&block)
-        global_hooks[:after_request_before_on_complete] << block
-      end
-
-      def run_global_hooks_for(name, request)
-        global_hooks[name].each { |hook| hook.call(request) }
-      end
-
-      def clear_global_hooks
-        global_hooks.clear
-      end
-    end
-  end
-end