dcu-typhoeus 0.4.0

data/lib/typhoeus/easy/options.rb

@@ -0,0 +1,115 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,82 @@
+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(:verifypeer, 0)
+      end
+
+      def disable_ssl_host_verification
+        set_option(: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

@@ -0,0 +1,115 @@
+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
+      @header ||= {}
+    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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,24 @@
+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

data/lib/typhoeus/hydra/connect_options.rb

@@ -0,0 +1,61 @@
+module Typhoeus
+  class Hydra
+    class NetConnectNotAllowedError < StandardError; end
+
+    module ConnectOptions
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # This method checks to see if we should raise an error on
+      # a request.
+      #
+      # @raises NetConnectNotAllowedError
+      def check_allow_net_connect!(request)
+        return if Typhoeus::Hydra.allow_net_connect?
+        return if Typhoeus::Hydra.ignore_hosts.include?(request.host_domain)
+
+        raise NetConnectNotAllowedError, "Real HTTP requests are not allowed. Unregistered request: #{request.inspect}"
+      end
+      private :check_allow_net_connect!
+
+      module ClassMethods
+        def self.extended(base)
+          class << base
+            attr_accessor :allow_net_connect
+            attr_accessor :ignore_localhost
+          end
+          base.allow_net_connect = true
+          base.ignore_localhost = false
+        end
+
+        # Returns whether we allow external HTTP connections.
+        # Useful for mocking/tests.
+        #
+        # @return [boolean] true/false
+        def allow_net_connect?
+          allow_net_connect
+        end
+
+        def ignore_localhost?
+          ignore_localhost
+        end
+
+        def ignore_hosts
+          @ignore_hosts ||= []
+
+          if ignore_localhost?
+            @ignore_hosts + Typhoeus::Request::LOCALHOST_ALIASES
+          else
+            @ignore_hosts
+          end
+        end
+
+        def ignore_hosts=(hosts)
+          @ignore_hosts = hosts
+        end
+      end
+    end
+  end
+end
+

data/lib/typhoeus/hydra/stubbing.rb

@@ -0,0 +1,68 @@
+module Typhoeus
+  class Hydra
+    module Stubbing
+      module SharedMethods
+        def stub(method, url, options = {})
+          stubs << HydraMock.new(url, method, options)
+          stubs.last
+        end
+
+        def clear_stubs
+          self.stubs = []
+        end
+
+        def register_stub_finder(&block)
+          stub_finders << block
+        end
+
+        def find_stub_from_request(request)
+          stub_finders.each do |finder|
+            if response = finder.call(request)
+              mock = HydraMock.new(/.*/, :any)
+              mock.and_return(response)
+              return mock
+            end
+          end
+
+          stubs.detect { |stub| stub.matches?(request) }
+        end
+
+        def stub_finders
+          @stub_finders ||= []
+        end
+
+        def self.extended(base)
+          class << base
+            attr_accessor :stubs
+          end
+          base.stubs = []
+        end
+      end
+
+      def self.included(base)
+        base.extend(SharedMethods)
+        base.class_eval do
+          attr_accessor :stubs
+        end
+      end
+
+      def assign_to_stub(request)
+        m = find_stub_from_request(request)
+
+        # Fallback to global stubs.
+        m ||= self.class.find_stub_from_request(request)
+
+        if m
+          m.add_request(request)
+          @active_stubs << m
+          m
+        else
+          nil
+        end
+      end
+      private :assign_to_stub
+
+      include SharedMethods
+    end
+  end
+end