typhoeus 0.4.2 → 0.5.0.alpha

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/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

data/lib/typhoeus/hydra/connect_options.rb

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

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

data/lib/typhoeus/hydra_mock.rb

@@ -1,131 +0,0 @@
-module Typhoeus
-  class HydraMock
-    attr_reader :url, :method, :requests, :uri
-
-    def initialize(url, method, options = {})
-      @url      = url
-      @uri      = URI.parse(url) if url.kind_of?(String)
-      @method   = method
-      @requests = []
-      @options = options
-      if @options[:headers]
-        @options[:headers] = Typhoeus::Header.new(@options[:headers])
-      end
-
-      @current_response_index = 0
-    end
-
-    def body
-      @options[:body]
-    end
-
-    def body?
-      @options.has_key?(:body)
-    end
-
-    def headers
-      @options[:headers]
-    end
-
-    def headers?
-      @options.has_key?(:headers)
-    end
-
-    def add_request(request)
-      @requests << request
-    end
-
-    def and_return(val)
-      if val.respond_to?(:each)
-        @responses = val
-      else
-        @responses = [val]
-      end
-
-      # make sure to mark them as a mock.
-      @responses.each { |r| r.mock = true }
-
-      val
-    end
-
-    def response
-      if @current_response_index == (@responses.length - 1)
-        @responses.last
-      else
-        value = @responses[@current_response_index]
-        @current_response_index += 1
-        value
-      end
-    end
-
-    def matches?(request)
-      if !method_matches?(request) or !url_matches?(request)
-        return false
-      end
-
-      if body?
-        return false unless body_matches?(request)
-      end
-
-      if headers?
-        return false unless headers_match?(request)
-      end
-
-      true
-    end
-
-  private
-    def method_matches?(request)
-      self.method == :any or self.method == request.method
-    end
-
-    def url_matches?(request)
-      if url.kind_of?(String)
-        request_uri = URI.parse(request.url)
-        request_uri == self.uri
-      else
-        self.url =~ request.url
-      end
-    end
-
-    def body_matches?(request)
-      !request.body.nil? && !request.body.empty? && request.body == self.body
-    end
-
-    def headers_match?(request)
-      request_headers = Header.new(request.headers)
-
-      if empty_headers?(self.headers)
-        empty_headers?(request_headers)
-      else
-        return false if empty_headers?(request_headers)
-
-        headers.each do |key, value|
-          return false unless header_value_matches?(value, request_headers[key])
-        end
-
-        true
-      end
-    end
-
-    def header_value_matches?(mock_value, request_value)
-      mock_arr = mock_value.is_a?(Array) ? mock_value : [mock_value]
-      request_arr = request_value.is_a?(Array) ? request_value : [request_value]
-
-      return false unless mock_arr.size == request_arr.size
-      mock_arr.all? do |value|
-        request_arr.any? { |a| value === a }
-      end
-    end
-
-    def empty_headers?(headers)
-      # We consider the default User-Agent header to be empty since
-      # Typhoeus always adds that.
-      headers.nil? || headers.empty? || default_typhoeus_headers?(headers)
-    end
-
-    def default_typhoeus_headers?(headers)
-      headers.size == 1 && headers['User-Agent'] == Typhoeus::USER_AGENT
-    end
-  end
-end