typhoeus_curly 0.1.14

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/hydra.rb

@@ -0,0 +1,207 @@
+module Typhoeus
+  class Hydra
+    def initialize(options = {})
+      @memoize_requests = true
+      @multi       = Multi.new
+      @easy_pool   = []
+      initial_pool_size = options[:initial_pool_size] || 10
+      @max_concurrency = options[:max_concurrency] || 200
+      initial_pool_size.times { @easy_pool << Easy.new }
+      @stubs       = []
+      @memoized_requests = {}
+      @retrieved_from_cache = {}
+      @queued_requests = []
+      @running_requests = 0
+    end
+
+    def self.hydra
+      @hydra ||= new
+    end
+
+    def self.hydra=(val)
+      @hydra = val
+    end
+
+    def clear_stubs
+      @stubs = []
+    end
+
+    def fire_and_forget
+      @queued_requests.each {|r| queue(r, false)}
+      @multi.fire_and_forget
+    end
+
+    def queue(request, obey_concurrency_limit = true)
+      return if assign_to_stub(request)
+
+      if @running_requests >= @max_concurrency && obey_concurrency_limit
+        @queued_requests << request
+      else
+        if request.method == :get
+          if @memoize_requests && @memoized_requests.has_key?(request.url)
+            if response = @retrieved_from_cache[request.url]
+              request.response = response
+              request.call_handlers
+            else
+              @memoized_requests[request.url] << request
+            end
+          else
+            @memoized_requests[request.url] = [] if @memoize_requests
+            get_from_cache_or_queue(request)
+          end
+        else
+          get_from_cache_or_queue(request)
+        end
+      end
+    end
+
+    def run
+      @stubs.each do |m|
+        m.requests.each do |request|
+          m.response.request = request
+          handle_request(request, m.response)
+        end
+      end
+      @multi.perform
+      @memoized_requests = {}
+      @retrieved_from_cache = {}
+    end
+
+    def disable_memoization
+      @memoize_requests = false
+    end
+
+    def cache_getter(&block)
+      @cache_getter = block
+    end
+
+    def cache_setter(&block)
+      @cache_setter = block
+    end
+
+    def on_complete(&block)
+      @on_complete = block
+    end
+
+    def on_complete=(proc)
+      @on_complete = proc
+    end
+
+    def stub(method, url)
+      @stubs << HydraMock.new(url, method)
+      @stubs.last
+    end
+
+    def assign_to_stub(request)
+      m = @stubs.detect {|stub| stub.matches? request}
+      m && m.add_request(request)
+    end
+    private :assign_to_stub
+
+    def get_from_cache_or_queue(request)
+      if @cache_getter
+        val = @cache_getter.call(request)
+        if val
+          @retrieved_from_cache[request.url] = val
+          handle_request(request, val, false)
+        else
+          @multi.add(get_easy_object(request))
+        end
+      else
+        @multi.add(get_easy_object(request))
+      end
+    end
+    private :get_from_cache_or_queue
+
+    def get_easy_object(request)
+      @running_requests += 1
+      easy = @easy_pool.pop || Easy.new
+      easy.url          = request.url
+      easy.method       = request.method
+      easy.params       = request.params  if request.method == :post && !request.params.nil?
+      easy.headers      = request.headers if request.headers
+      easy.request_body = request.body    if request.body
+      easy.timeout      = request.timeout if request.timeout
+      easy.follow_location = request.follow_location if request.follow_location
+      easy.max_redirects = request.max_redirects if request.max_redirects
+      easy.on_success do |easy|
+        queue_next
+        handle_request(request, response_from_easy(easy, request))
+        release_easy_object(easy)
+      end
+      easy.on_failure do |easy|
+        queue_next
+        handle_request(request, response_from_easy(easy, request))
+        release_easy_object(easy)
+      end
+      easy.set_headers
+      easy
+    end
+    private :get_easy_object
+
+    def queue_next
+      @running_requests -= 1
+      queue(@queued_requests.pop) unless @queued_requests.empty?
+    end
+    private :queue_next
+
+    def release_easy_object(easy)
+      easy.reset
+      @easy_pool.push easy
+    end
+    private :release_easy_object
+
+    def handle_request(request, response, live_request = true)
+      request.response = response
+
+      if live_request && request.cache_timeout && @cache_setter
+        @cache_setter.call(request)
+      end
+      @on_complete.call(response) if @on_complete
+
+      request.call_handlers
+      if requests = @memoized_requests[request.url]
+        requests.each do |r|
+          r.response = response
+          r.call_handlers
+        end
+      end
+    end
+    private :handle_request
+
+    def response_from_easy(easy, request)
+      Response.new(:code    => easy.response_code,
+                   :headers => easy.response_header,
+                   :body    => easy.response_body,
+                   :time    => easy.total_time_taken,
+                   :request => request)
+    end
+    private :response_from_easy
+  end
+
+  class HydraMock
+    attr_reader :url, :method, :response, :requests
+
+    def initialize(url, method)
+      @url      = url
+      @method   = method
+      @requests = []
+    end
+
+    def add_request(request)
+      @requests << request
+    end
+
+    def and_return(val)
+      @response = val
+    end
+
+    def matches?(request)
+      if url.kind_of?(String)
+        request.method == method && request.url == url
+      else
+        request.method == method && url =~ request.url
+      end
+    end
+  end
+end

data/lib/typhoeus/multi.rb

@@ -0,0 +1,34 @@
+module Typhoeus
+  class Multi
+    attr_reader :easy_handles
+
+    def initialize
+      reset_easy_handles
+    end
+
+    def remove(easy)
+      multi_remove_handle(easy)
+    end
+    
+    def add(easy)
+      @easy_handles << easy
+      multi_add_handle(easy)
+    end
+    
+    def perform()
+      while active_handle_count > 0 do
+        multi_perform
+      end
+      reset_easy_handles
+    end
+    
+    def cleanup()
+      multi_cleanup
+    end
+
+    private
+    def reset_easy_handles
+      @easy_handles = []
+    end
+  end
+end

data/lib/typhoeus/remote.rb

@@ -0,0 +1,306 @@
+module Typhoeus
+  USER_AGENT = "Typhoeus - http://github.com/pauldix/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