typhoeus 0.4.2 → 0.5.0.alpha

data/lib/typhoeus/remote_method.rb

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

data/lib/typhoeus/remote_proxy_object.rb

@@ -1,50 +0,0 @@
-module Typhoeus
-  class RemoteProxyObject
-    instance_methods.each { |m| undef_method m unless m =~ /^__|object_id/ }
-
-    def initialize(clear_memoized_store_proc, easy, options = {})
-      @clear_memoized_store_proc = clear_memoized_store_proc
-      @easy      = easy
-      @success   = options[:on_success]
-      @failure   = options[:on_failure]
-      @cache     = options.delete(:cache)
-      @cache_key = options.delete(:cache_key)
-      @timeout   = options.delete(:cache_timeout)
-      Typhoeus.add_easy_request(@easy)
-    end
-
-    def method_missing(sym, *args, &block)
-      unless @proxied_object
-        if @cache && @cache_key
-          @proxied_object = @cache.get(@cache_key) rescue nil
-        end
-
-        unless @proxied_object
-          Typhoeus.perform_easy_requests
-          response = Response.new(:code => @easy.response_code,
-                                  :curl_return_code => @easy.curl_return_code,
-                                  :curl_error_message => @easy.curl_error_message,
-                                  :headers => @easy.response_header,
-                                  :body => @easy.response_body,
-                                  :time => @easy.total_time_taken,
-                                  :requested_url => @easy.url,
-                                  :requested_http_method => @easy.method,
-                                  :start_time => @easy.start_time)
-          if @easy.response_code >= 200 && @easy.response_code < 300
-            Typhoeus.release_easy_object(@easy)
-            @proxied_object = @success.nil? ? response : @success.call(response)
-
-            if @cache && @cache_key
-              @cache.set(@cache_key, @proxied_object, @timeout)
-            end
-          else
-            @proxied_object = @failure.nil? ? response : @failure.call(response)
-          end
-         @clear_memoized_store_proc.call
-       end
-      end
-
-      @proxied_object.__send__(sym, *args, &block)
-    end
-  end
-end

data/lib/typhoeus/utils.rb

@@ -1,50 +0,0 @@
-module Typhoeus
-  module Utils
-    # Taken from Rack::Utils, 1.2.1 to remove Rack dependency.
-    def escape(s)
-      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
-        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-      }.tr(' ', '+')
-    end
-    module_function :escape
-
-    # Params are NOT escaped.
-    def traverse_params_hash(hash, result = nil, current_key = nil)
-      result = ParamProcessor.traverse_params_hash hash, result, current_key
-    end
-    module_function :traverse_params_hash
-
-    def traversal_to_param_string(traversal, escape = true)
-      traversal[:params].collect { |param|
-        escape ? "#{Typhoeus::Utils.escape(param[0])}=#{Typhoeus::Utils.escape(param[1])}" : "#{param[0]}=#{param[1]}"
-      }.join('&')
-    end
-    module_function :traversal_to_param_string
-
-    # Return the bytesize of String; uses String#size under Ruby 1.8 and
-    # String#bytesize under 1.9.
-    if ''.respond_to?(:bytesize)
-      def bytesize(string)
-        string.bytesize
-      end
-    else
-      def bytesize(string)
-        string.size
-      end
-    end
-    module_function :bytesize
-
-    # Return a byteslice from a string; uses String#[] under Ruby 1.8 and
-    # String#byteslice under 1.9.
-    if ''.respond_to?(:byteslice)
-      def byteslice(string, *args)
-        string.byteslice(*args)
-      end
-    else
-      def byteslice(string, *args)
-        string[*args]
-      end
-    end
-    module_function :byteslice
-  end
-end