typhoeus 0.4.2 → 1.4.0

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

data/lib/typhoeus/multi.rb

@@ -1,146 +0,0 @@
-module Typhoeus
-  class Multi
-    attr_reader :easy_handles
-
-    def initialize
-      Curl.init
-
-      @handle = Curl.multi_init
-      @active = 0
-      @running = 0
-      @easy_handles = []
-
-      @timeout = ::FFI::MemoryPointer.new(:long)
-      @timeval = Curl::Timeval.new
-      @fd_read = Curl::FDSet.new
-      @fd_write = Curl::FDSet.new
-      @fd_excep = Curl::FDSet.new
-      @max_fd = ::FFI::MemoryPointer.new(:int)
-
-      ObjectSpace.define_finalizer(self, self.class.finalizer(self))
-    end
-
-    def self.finalizer(multi)
-      proc { Curl.multi_cleanup(multi.handle) }
-    end
-
-    def add(easy)
-      raise "trying to add easy handle twice" if @easy_handles.include?(easy)
-      easy.set_headers() if easy.headers.empty?
-
-      code = Curl.multi_add_handle(@handle, easy.handle)
-      raise RuntimeError.new("An error occured adding the handle: #{code}: #{Curl.multi_strerror(code)}") if code != :call_multi_perform and code != :ok
-
-      do_perform if code == :call_multi_perform
-
-      @active += 1
-      @easy_handles << easy
-      easy
-    end
-
-    def remove(easy)
-      if @easy_handles.include?(easy)
-        @active -= 1
-        Curl.multi_remove_handle(@handle, easy.handle)
-        @easy_handles.delete(easy)
-      end
-    end
-
-    def perform
-      while @active > 0
-        run
-        while @running > 0
-          # get the curl-suggested timeout
-          code = Curl.multi_timeout(@handle, @timeout)
-          raise RuntimeError.new("an error occured getting the timeout: #{code}: #{Curl.multi_strerror(code)}") if code != :ok
-          timeout = @timeout.read_long
-          if timeout == 0 # no delay
-            run
-            next
-          elsif timeout < 0
-            timeout = 1
-          end
-
-          # load the fd sets from the multi handle
-          @fd_read.clear
-          @fd_write.clear
-          @fd_excep.clear
-          code = Curl.multi_fdset(@handle, @fd_read, @fd_write, @fd_excep, @max_fd)
-          raise RuntimeError.new("an error occured getting the fdset: #{code}: #{Curl.multi_strerror(code)}") if code != :ok
-
-          max_fd = @max_fd.read_int
-          if max_fd == -1
-            # curl is doing something special so let it run for a moment
-            sleep(0.001)
-          else
-            @timeval[:sec] = timeout / 1000
-            @timeval[:usec] = (timeout * 1000) % 1000000
-
-            code = Curl.select(max_fd + 1, @fd_read, @fd_write, @fd_excep, @timeval)
-            raise RuntimeError.new("error on thread select: #{::FFI.errno}") if code < 0
-          end
-
-          run
-        end
-      end
-      reset_easy_handles
-    end
-
-    def fire_and_forget
-      run
-    end
-
-    # check for finished easy handles and remove from the multi handle
-    def read_info
-      msgs_left = ::FFI::MemoryPointer.new(:int)
-      while not (msg = Curl.multi_info_read(@handle, msgs_left)).null?
-        next if msg[:code] != :done
-
-        easy = @easy_handles.find {|easy| easy.handle == msg[:easy_handle] }
-        next if not easy
-
-        response_code = ::FFI::MemoryPointer.new(:long)
-        response_code.write_long(-1)
-        Curl.easy_getinfo(easy.handle, :response_code, response_code)
-        response_code = response_code.read_long
-        remove(easy)
-
-        easy.curl_return_code = msg[:data][:code]
-        if easy.curl_return_code != 0 then easy.failure
-        elsif (200..299).member?(response_code) or response_code == 0 then easy.success
-        else easy.failure
-        end
-      end
-    end
-
-    def cleanup
-      Curl.multi_cleanup(@handle)
-      @active = 0
-      @running = 0
-      @easy_handles = []
-    end
-
-    def reset_easy_handles
-      @easy_handles.dup.each do |easy|
-        remove(easy)
-        yield easy if block_given?
-      end
-    end
-
-    private
-
-    # called by perform and fire_and_forget
-    def run
-      begin code = do_perform end while code == :call_multi_perform
-      raise RuntimeError.new("an error occured while running perform: #{code}: #{Curl.multi_strerror(code)}") if code != :ok
-      read_info
-    end
-
-    def do_perform
-      running = ::FFI::MemoryPointer.new(:int)
-      code = Curl.multi_perform(@handle, running)
-      @running = running.read_int
-      code
-    end
-  end
-end

data/lib/typhoeus/param_processor.rb

@@ -1,43 +0,0 @@
-require 'tempfile'
-
-module Typhoeus
-  class ParamProcessor
-    class << self
-      def traverse_params_hash(hash, result = nil, current_key = nil)
-        result ||= { :files => [], :params => [] }
-
-        hash.keys.sort { |a, b| a.to_s <=> b.to_s }.collect do |key|
-          new_key = (current_key ? "#{current_key}[#{key}]" : key).to_s
-          current_value = hash[key]
-          process_value current_value, :result => result, :new_key => new_key
-        end
-        result
-      end
-
-      def process_value(current_value, options)
-        result = options[:result]
-        new_key = options[:new_key]
-
-        case current_value
-        when Hash
-          traverse_params_hash(current_value, result, new_key)
-        when Array
-          current_value.each do |v|
-            result[:params] << [new_key, v.to_s]
-          end
-        when File, Tempfile
-          filename = File.basename(current_value.path)
-          types = MIME::Types.type_for(filename)
-          result[:files] << [
-            new_key,
-            filename,
-            types.empty? ? 'application/octet-stream' : types[0].to_s,
-            File.expand_path(current_value.path)
-          ]
-        else
-          result[:params] << [new_key, current_value.to_s]
-        end
-      end
-    end
-  end
-end

data/lib/typhoeus/remote.rb

@@ -1,306 +0,0 @@
-module Typhoeus
-  USER_AGENT = "Typhoeus - http://github.com/dbalatero/typhoeus/tree/master"
-  
-  def self.included(base)
-    base.extend ClassMethods
-  end
-
-  class MockExpectedError < StandardError; end
-    
-  module ClassMethods
-    def allow_net_connect
-      @allow_net_connect = true if @allow_net_connect.nil?
-      @allow_net_connect
-    end
-
-    def allow_net_connect=(value)
-      @allow_net_connect = value
-    end
-    
-    def mock(method, args = {})
-      @remote_mocks ||= {}
-      @remote_mocks[method] ||= {}
-      args[:code]    ||= 200
-      args[:body]    ||= ""
-      args[:headers] ||= ""
-      args[:time]    ||= 0
-      url = args.delete(:url)
-      url ||= :catch_all
-      params = args.delete(:params)
-
-      key = mock_key_for(url, params)
-
-      @remote_mocks[method][key] = args
-    end
-
-    # Returns a key for a given URL and passed in 
-    # set of Typhoeus options to be used to store/retrieve
-    # a corresponding mock.
-    def mock_key_for(url, params = nil)
-      if url == :catch_all
-        url
-      else
-        key = url
-        if params and !params.empty?
-          key += flatten_and_sort_hash(params).to_s
-        end
-        key
-      end
-    end
-
-    def flatten_and_sort_hash(params)
-      params = params.dup
-
-      # Flatten any sub-hashes to a single string.
-      params.keys.each do |key|
-        if params[key].is_a?(Hash)
-          params[key] = params[key].sort_by { |k, v| k.to_s.downcase }.to_s
-        end
-      end
-
-      params.sort_by { |k, v| k.to_s.downcase }
-    end
-    
-    def get_mock(method, url, options)
-      return nil unless @remote_mocks
-      if @remote_mocks.has_key? method
-        extra_response_args = { :requested_http_method => method,
-                                :requested_url => url,
-                                :start_time => Time.now }
-        mock_key = mock_key_for(url, options[:params])
-        if @remote_mocks[method].has_key? mock_key
-          get_mock_and_run_handlers(method,
-                                    @remote_mocks[method][mock_key].merge(
-                                      extra_response_args),
-                                    options)
-        elsif @remote_mocks[method].has_key? :catch_all
-          get_mock_and_run_handlers(method,
-                                    @remote_mocks[method][:catch_all].merge(
-                                      extra_response_args),
-                                    options)
-        else
-          nil
-        end
-      else
-        nil
-      end
-    end
-
-    def enforce_allow_net_connect!(http_verb, url, params = nil)
-      if !allow_net_connect
-        message = "Real HTTP connections are disabled. Unregistered request: " <<
-                  "#{http_verb.to_s.upcase} #{url}\n" <<
-                  "  Try: mock(:#{http_verb}, :url => \"#{url}\""
-        if params
-          message << ",\n            :params => #{params.inspect}"
-        end
-
-        message << ")"
-
-        raise MockExpectedError, message
-      end
-    end
-
-    def check_expected_headers!(response_args, options)
-      missing_headers = {}
-
-      response_args[:expected_headers].each do |key, value|
-        if options[:headers].nil?
-          missing_headers[key] = [value, nil]
-        elsif ((options[:headers][key] && value != :anything) &&
-           options[:headers][key] != value)
-
-          missing_headers[key] = [value, options[:headers][key]]
-        end
-      end
-
-      unless missing_headers.empty?
-        raise headers_error_summary(response_args, options, missing_headers, 'expected')
-      end
-    end
-
-    def check_unexpected_headers!(response_args, options)
-      bad_headers = {}
-      response_args[:unexpected_headers].each do |key, value|
-        if (options[:headers][key] && value == :anything) ||
-           (options[:headers][key] == value)
-          bad_headers[key] = [value, options[:headers][key]]
-        end
-      end
-
-      unless bad_headers.empty?
-        raise headers_error_summary(response_args, options, bad_headers, 'did not expect')
-      end
-    end
-
-    def headers_error_summary(response_args, options, missing_headers, lead_in)
-      error = "#{lead_in} the following headers: #{response_args[:expected_headers].inspect}, but received: #{options[:headers].inspect}\n\n"
-      error   << "Differences:\n"
-      error   << "------------\n"
-      missing_headers.each do |key, values|
-        error << "  - #{key}: #{lead_in} #{values[0].inspect}, got #{values[1].inspect}\n"
-      end
-
-      error
-    end
-    private :headers_error_summary
-
-    def get_mock_and_run_handlers(method, response_args, options)
-      response = Response.new(response_args)
-     
-      if response_args.has_key? :expected_body
-        raise "#{method} expected body of \"#{response_args[:expected_body]}\" but received #{options[:body]}" if response_args[:expected_body] != options[:body]
-      end
-      
-      if response_args.has_key? :expected_headers
-        check_expected_headers!(response_args, options)
-      end
-
-      if response_args.has_key? :unexpected_headers
-        check_unexpected_headers!(response_args, options)
-      end
-
-      if response.code >= 200 && response.code < 300 && options.has_key?(:on_success)
-        response = options[:on_success].call(response)
-      elsif options.has_key?(:on_failure)
-        response = options[:on_failure].call(response)
-      end
-
-      encode_nil_response(response)
-    end
-       
-    [:get, :post, :put, :delete].each do |method|
-      line = __LINE__ + 2  # get any errors on the correct line num
-      code = <<-SRC
-        def #{method.to_s}(url, options = {})
-          mock_object = get_mock(:#{method.to_s}, url, options)
-          unless mock_object.nil?
-            decode_nil_response(mock_object)
-          else
-            enforce_allow_net_connect!(:#{method.to_s}, url, options[:params])
-            remote_proxy_object(url, :#{method.to_s}, options)
-          end
-        end
-      SRC
-      module_eval(code, "./lib/typhoeus/remote.rb", line)
-    end
-    
-    def remote_proxy_object(url, method, options)
-      easy = Typhoeus.get_easy_object
-      
-      easy.url                   = url
-      easy.method                = method
-      easy.headers               = options[:headers] if options.has_key?(:headers)
-      easy.headers["User-Agent"] = (options[:user_agent] || Typhoeus::USER_AGENT)
-      easy.params                = options[:params] if options[:params]
-      easy.request_body          = options[:body] if options[:body]
-      easy.timeout               = options[:timeout] if options[:timeout]
-      easy.set_headers
-      
-      proxy = Typhoeus::RemoteProxyObject.new(clear_memoized_proxy_objects, easy, options)
-      set_memoized_proxy_object(method, url, options, proxy)
-    end
-    
-    def remote_defaults(options)
-      @remote_defaults ||= {}
-      @remote_defaults.merge!(options) if options
-      @remote_defaults
-    end
-
-    # If we get subclassed, make sure that child inherits the remote defaults
-    # of the parent class.
-    def inherited(child)
-      child.__send__(:remote_defaults, @remote_defaults)
-    end
-    
-    def call_remote_method(method_name, args)
-      m = @remote_methods[method_name]
-      
-      base_uri = args.delete(:base_uri) || m.base_uri || ""
-
-      if args.has_key? :path
-        path = args.delete(:path)
-      else
-        path = m.interpolate_path_with_arguments(args)
-      end
-      path ||= ""
-      
-      http_method = m.http_method
-      url         = base_uri + path
-      options     = m.merge_options(args)
-      
-      # proxy_object = memoized_proxy_object(http_method, url, options)
-      # return proxy_object unless proxy_object.nil?
-      # 
-      # if m.cache_responses?
-      #   object = @cache.get(get_memcache_response_key(method_name, args))
-      #   if object
-      #     set_memoized_proxy_object(http_method, url, options, object)
-      #     return object
-      #   end
-      # end
-
-      proxy = memoized_proxy_object(http_method, url, options)
-      unless proxy
-        if m.cache_responses?
-          options[:cache] = @cache
-          options[:cache_key] = get_memcache_response_key(method_name, args)
-          options[:cache_timeout] = m.cache_ttl
-        end
-        proxy = send(http_method, url, options)
-      end
-      proxy
-    end
-    
-    def set_memoized_proxy_object(http_method, url, options, object)
-      @memoized_proxy_objects ||= {}
-      @memoized_proxy_objects["#{http_method}_#{url}_#{options.to_s}"] = object
-    end
-    
-    def memoized_proxy_object(http_method, url, options)
-      @memoized_proxy_objects ||= {}
-      @memoized_proxy_objects["#{http_method}_#{url}_#{options.to_s}"]
-    end
-    
-    def clear_memoized_proxy_objects
-      lambda { @memoized_proxy_objects = {} }
-    end
-
-    def get_memcache_response_key(remote_method_name, args)
-      result = "#{remote_method_name.to_s}-#{args.to_s}"
-      (Digest::SHA2.new << result).to_s
-    end
-    
-    def cache=(cache)
-      @cache = cache
-    end
-    
-    def define_remote_method(name, args = {})
-      @remote_defaults  ||= {}
-      args[:method]     ||= @remote_defaults[:method]
-      args[:on_success] ||= @remote_defaults[:on_success]
-      args[:on_failure] ||= @remote_defaults[:on_failure]
-      args[:base_uri]   ||= @remote_defaults[:base_uri]
-      args[:path]       ||= @remote_defaults[:path]
-      m = RemoteMethod.new(args)
-
-      @remote_methods ||= {}
-      @remote_methods[name] = m
-
-      class_eval <<-SRC
-        def self.#{name.to_s}(args = {})
-          call_remote_method(:#{name.to_s}, args)
-        end
-      SRC
-    end
-
-    private
-    def encode_nil_response(response)
-      response == nil ? :__nil__ : response
-    end
-
-    def decode_nil_response(response)
-      response == :__nil__ ? nil : response
-    end
-  end # ClassMethods
-end