dbalatero-typhoeus 0.0.20

data/lib/typhoeus/easy.rb

@@ -0,0 +1,210 @@
+module Typhoeus
+  class Easy
+    attr_reader :response_body, :response_header, :method, :headers, :url
+    attr_accessor :start_time
+
+    CURLINFO_STRING = 1048576
+    OPTION_VALUES = {
+      :CURLOPT_URL            => 10002,
+      :CURLOPT_HTTPGET        => 80,
+      :CURLOPT_HTTPPOST       => 10024,
+      :CURLOPT_UPLOAD         => 46,
+      :CURLOPT_CUSTOMREQUEST  => 10036,
+      :CURLOPT_POSTFIELDS     => 10015,
+      :CURLOPT_POSTFIELDSIZE  => 60,
+      :CURLOPT_USERAGENT      => 10018,
+      :CURLOPT_TIMEOUT_MS     => 155,
+      :CURLOPT_NOSIGNAL       => 99,
+      :CURLOPT_HTTPHEADER     => 10023,
+      :CURLOPT_FOLLOWLOCATION => 52
+    }
+    INFO_VALUES = {
+      :CURLINFO_RESPONSE_CODE => 2097154,
+      :CURLINFO_TOTAL_TIME    => 3145731
+    }
+    
+    def initialize
+      @method = :get
+      @post_dat_set = nil
+      @headers = {}
+    end
+    
+    def headers=(hash)
+      @headers = hash
+    end
+    
+    def total_time_taken
+      get_info_double(INFO_VALUES[:CURLINFO_TOTAL_TIME])
+    end
+    
+    def response_code
+      get_info_long(INFO_VALUES[:CURLINFO_RESPONSE_CODE])
+    end
+    
+    def follow_location=(boolean)
+      if boolean
+        set_option(OPTION_VALUES[:CURLOPT_FOLLOWLOCATION], 1)
+      else
+        set_option(OPTION_VALUES[:CURLOPT_FOLLOWLOCATION], 0)
+      end
+    end
+    
+    def timeout=(milliseconds)
+      @timeout = milliseconds
+      set_option(OPTION_VALUES[:CURLOPT_NOSIGNAL], 1)
+      set_option(OPTION_VALUES[:CURLOPT_TIMEOUT_MS], milliseconds)
+    end
+    
+    def timed_out?
+      @timeout && total_time_taken > @timeout && response_code == 0
+    end
+    
+    def request_body=(request_body)
+      @request_body = request_body
+      if @method == :put
+        easy_set_request_body(@request_body)
+        headers["Transfer-Encoding"] = ""
+        headers["Expect"] = ""
+      else
+        self.post_data = request_body
+      end
+    end
+    
+    def user_agent=(user_agent)
+      set_option(OPTION_VALUES[:CURLOPT_USERAGENT], user_agent)
+    end
+          
+    def url=(url)
+      @url = url
+      set_option(OPTION_VALUES[:CURLOPT_URL], url)
+    end
+    
+    def method=(method)
+      @method = method
+      if method == :get
+        set_option(OPTION_VALUES[:CURLOPT_HTTPGET], 1)
+      elsif method == :post
+        set_option(OPTION_VALUES[:CURLOPT_HTTPPOST], 1)
+        self.post_data = ""
+      elsif method == :put
+        set_option(OPTION_VALUES[:CURLOPT_UPLOAD], 1)
+        self.request_body = "" unless @request_body
+      else
+        set_option(OPTION_VALUES[:CURLOPT_CUSTOMREQUEST], "DELETE")
+      end
+    end
+    
+    def post_data=(data)
+      @post_data_set = true
+      set_option(OPTION_VALUES[:CURLOPT_POSTFIELDS], data)
+      set_option(OPTION_VALUES[:CURLOPT_POSTFIELDSIZE], data.length)
+    end
+    
+    def params=(params)
+      params_string = params.keys.collect do |k|
+        value = params[k]
+        if value.is_a? Hash
+          value.keys.collect {|sk| CGI.escape("#{k}[#{sk}]") + "=" + CGI.escape(value[sk].to_s)}
+        elsif value.is_a? Array
+          key = CGI.escape(k.to_s)
+          value.collect { |v| "#{key}=#{CGI.escape(v.to_s)}" }.join('&')
+        else
+          "#{CGI.escape(k.to_s)}=#{CGI.escape(params[k].to_s)}"
+        end
+      end.flatten.join("&")
+      
+      if method == :post
+        self.post_data = params_string
+      else
+        self.url = "#{url}?#{params_string}"
+      end
+    end
+    
+    def set_option(option, value)
+      if value.class == String
+        easy_setopt_string(option, value)
+      else
+        easy_setopt_long(option, value)
+      end
+    end
+    
+    def perform
+      set_headers()
+      easy_perform()
+      response_code()
+    end
+    
+    def set_headers
+      headers.each_pair do |key, value|
+        easy_add_header("#{key}: #{value}")
+      end
+      easy_set_headers() unless headers.empty?
+    end
+    
+    # gets called when finished and response code is 200-299
+    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
+    def failure
+      @failure.call(self) if @failure
+    end
+    
+    def on_failure(&block)
+      @failure = block
+    end
+    
+    def on_failure=(block)
+      @failure = block
+    end
+
+    def retries
+      @retries ||= 0
+    end
+    
+    def increment_retries
+      @retries ||= 0
+      @retries += 1
+    end
+    
+    def max_retries
+      @max_retries ||= 40
+    end
+    
+    def max_retries?
+      retries >= max_retries
+    end
+    
+    def reset
+      @response_code = 0
+      @response_header = ""
+      @response_body = ""
+      easy_reset()
+    end
+    
+    def get_info_string(option)
+      easy_getinfo_string(option)
+    end
+    
+    def get_info_long(option)
+      easy_getinfo_long(option)
+    end
+    
+    def get_info_double(option)
+      easy_getinfo_double(option)
+    end
+    
+    def curl_version
+      version
+    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/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

data/lib/typhoeus/remote_method.rb

@@ -0,0 +1,108 @@
+module Typhoeus
+  class RemoteMethod
+    attr_accessor :http_method, :options, :base_uri, :path, :on_success, :on_failure, :cache_ttl
+    
+    def initialize(options = {})
+      @http_method       = options.delete(:method) || :get
+      @options           = options
+      @base_uri          = options.delete(:base_uri)
+      @path              = options.delete(:path)
+      @on_success        = options[:on_success]
+      @on_failure        = options[:on_failure]
+      @cache_responses   = options.delete(:cache_responses)
+      @memoize_responses = options.delete(:memoize_responses) || @cache_responses
+      @cache_ttl         = @cache_responses == true ? 0 : @cache_responses
+      @keys              = nil
+      
+      clear_cache
+    end
+    
+    def cache_responses?
+      @cache_responses
+    end
+    
+    def memoize_responses?
+      @memoize_responses
+    end
+    
+    def args_options_key(args, options)
+      "#{args.to_s}+#{options.to_s}"
+    end
+    
+    def calling(args, options)
+      @called_methods[args_options_key(args, options)] = true
+    end
+    
+    def already_called?(args, options)
+      @called_methods.has_key? args_options_key(args, options)
+    end
+    
+    def add_response_block(block, args, options)
+      @response_blocks[args_options_key(args, options)] << block
+    end
+    
+    def call_response_blocks(result, args, options)
+      key = args_options_key(args, options)
+      @response_blocks[key].each {|block| block.call(result)}
+      @response_blocks.delete(key)
+      @called_methods.delete(key)
+    end
+    
+    def clear_cache
+      @response_blocks  = Hash.new {|h, k| h[k] = []}
+      @called_methods   = {}      
+    end
+    
+    def merge_options(new_options)
+      merged = options.merge(new_options)
+      if options.has_key?(:params) && new_options.has_key?(:params)
+        merged[:params] = options[:params].merge(new_options[:params])
+      end
+      argument_names.each {|a| merged.delete(a)}
+      merged.delete(:on_success) if merged[:on_success].nil?
+      merged.delete(:on_failure) if merged[:on_failure].nil?
+      merged
+    end
+    
+    def interpolate_path_with_arguments(args)
+      interpolated_path = @path
+      argument_names.each do |arg|
+        interpolated_path = interpolated_path.gsub(":#{arg}", args[arg].to_s)
+      end
+      interpolated_path
+    end
+    
+    def argument_names
+      return @keys if @keys
+      pattern, keys = compile(@path)
+      @keys = keys.collect {|k| k.to_sym}
+    end
+    
+    # rippped from Sinatra. clean up stuff we don't need later
+    def compile(path)
+      path ||= ""
+      keys = []
+      if path.respond_to? :to_str
+        special_chars = %w{. + ( )}
+        pattern =
+          path.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            case match
+            when "*"
+              keys << 'splat'
+              "(.*?)"
+            when *special_chars
+              Regexp.escape(match)
+            else
+              keys << $2[1..-1]
+              "([^/?&#]+)"
+            end
+          end
+        [/^#{pattern}$/, keys]
+      elsif path.respond_to? :match
+        [path, keys]
+      else
+        raise TypeError, path
+      end
+    end
+  end
+end