typhoeus 0.4.2 → 0.5.0.pre

data/lib/typhoeus/request.rb

@@ -1,266 +1,81 @@
-require 'uri'
+require 'typhoeus/requests/callbacks'
+require 'typhoeus/requests/actions'
+require 'typhoeus/requests/operations'
+require 'typhoeus/requests/marshal'
+require 'typhoeus/requests/responseable'
+require 'typhoeus/requests/memoizable'
 
 module Typhoeus
+
+  # This class represents a request.
   class Request
-    ACCESSOR_OPTIONS = [
-      :method,
-      :params,
-      :body,
-      :headers,
-      :cache_key_basis,
-      :connect_timeout,
-      :timeout,
-      :user_agent,
-      :response,
-      :cache_timeout,
-      :follow_location,
-      :max_redirects,
-      :proxy,
-      :proxy_username,
-      :proxy_password,
-      :disable_ssl_peer_verification,
-      :disable_ssl_host_verification,
-      :interface,
-      :ssl_cert,
-      :ssl_cert_type,
-      :ssl_key,
-      :ssl_key_type,
-      :ssl_key_password,
-      :ssl_cacert,
-      :ssl_capath,
-      :ssl_version,
-      :verbose,
-      :username,
-      :password,
-      :auth_method,
-      :proxy_auth_method,
-      :proxy_type
-    ]
+    include Requests::Callbacks
+    include Requests::Marshal
+    include Requests::Operations
+    extend  Requests::Actions
+    include Requests::Responseable
+    include Requests::Memoizable
 
-    attr_accessor *ACCESSOR_OPTIONS
+    attr_accessor :options, :url, :hydra
 
-    # Initialize a new Request
+    # Create a new request.
+    #
+    # @example Create a request.
+    #   Request.new("www.example.com")
     #
-    # Options:
-    # * +url+ : Endpoint (URL) of the request
-    # * +options+   : A hash containing options among :
-    # ** +:method+  : :get (default) / :post / :put
-    # ** +:params+  : params as a Hash
-    # ** +:body+
-    # ** +:timeout+ : timeout (ms)
-    # ** +:interface+ : interface or ip address (string)
-    # ** +:connect_timeout+ : connect timeout (ms)
-    # ** +:headers+  : headers as Hash
-    # ** +:cache_timeout+ : cache timeout (ms)
-    # ** +:follow_location
-    # ** +:max_redirects
-    # ** +:proxy
-    # ** +:disable_ssl_peer_verification
-    # ** +:disable_ssl_host_verification
-    # ** +:ssl_cert
-    # ** +:ssl_cert_type
-    # ** +:ssl_key
-    # ** +:ssl_key_type
-    # ** +:ssl_key_password
-    # ** +:ssl_cacert
-    # ** +:ssl_capath
-    # ** +:verbose
-    # ** +:username
-    # ** +:password
-    # ** +:auth_method
+    # @param [ String ] url The url to request.
+    # @param [ Hash ] options The options.
     #
+    # #return [ Request ] The new request.
     def initialize(url, options = {})
       @url = url
-      @method           = options[:method] || :get
-      @params           = options[:params]
-      @body             = options[:body]
-      @timeout          = safe_to_i(options[:timeout])
-      @connect_timeout  = safe_to_i(options[:connect_timeout])
-      @interface        = options[:interface]
-      @headers          = options[:headers] || {}
-
-      @cache_timeout    = safe_to_i(options[:cache_timeout])
-      @follow_location  = options[:follow_location]
-      @max_redirects    = options[:max_redirects]
-      @proxy            = options[:proxy]
-      @proxy_type       = options[:proxy_type]
-      @proxy_username   = options[:proxy_username]
-      @proxy_password   = options[:proxy_password]
-      @proxy_auth_method = options[:proxy_auth_method]
-      @disable_ssl_peer_verification = options[:disable_ssl_peer_verification]
-      @disable_ssl_host_verification = options[:disable_ssl_host_verification]
-      @ssl_cert         = options[:ssl_cert]
-      @ssl_cert_type    = options[:ssl_cert_type]
-      @ssl_key          = options[:ssl_key]
-      @ssl_key_type     = options[:ssl_key_type]
-      @ssl_key_password = options[:ssl_key_password]
-      @ssl_cacert       = options[:ssl_cacert]
-      @ssl_capath       = options[:ssl_capath]
-      @ssl_version      = options[:ssl_version]
-      @verbose          = options[:verbose]
-      @username         = options[:username]
-      @password         = options[:password]
-      @auth_method      = options[:auth_method]
-
-      @on_complete      = nil
-      @after_complete   = nil
-      @handled_response = nil
-    end
+      @options = options.dup
 
-    LOCALHOST_ALIASES = %w[ localhost 127.0.0.1 0.0.0.0 ]
-
-    def localhost?
-      LOCALHOST_ALIASES.include?(parsed_uri.host)
-    end
-
-    def user_agent
-      headers['User-Agent']
-    end
-
-    def url
-      if [:post, :put].include?(@method)
-        @url
-      else
-        url = "#{@url}?#{params_string}"
-        url += "&#{URI.escape(@body)}" if @body
-        url.gsub("?&", "?").gsub(/\?$/, '')
-      end
-    end
-
-    def parsed_uri
-      @parsed_uri ||= URI.parse(@url)
-    end
-
-    def host
-      slash_location = @url.index('/', 8)
-      if slash_location
-        @url.slice(0, slash_location)
+      if @options[:headers]
+        @options[:headers] = {'User-Agent' => Typhoeus::USER_AGENT}.merge(options[:headers])
       else
-        query_string_location = @url.index('?')
-        return query_string_location ? @url.slice(0, query_string_location) : @url
-      end
-    end
-
-    def host_domain
-      parsed_uri.host
-    end
-
-    def params_string
-      return nil unless params
-      traversal = Typhoeus::Utils.traverse_params_hash(params)
-      Typhoeus::Utils.traversal_to_param_string(traversal)
-    end
-
-    def on_complete(&block)
-      @on_complete = block
-    end
-
-    def on_complete=(proc)
-      @on_complete = proc
-    end
-
-    def after_complete(&block)
-      @after_complete = block
-    end
-
-    def after_complete=(proc)
-      @after_complete = proc
-    end
-
-    def call_handlers
-      if @on_complete
-        @handled_response = @on_complete.call(response)
-        call_after_complete
-      end
-    end
-
-    def call_after_complete
-      @after_complete.call(@handled_response) if @after_complete
-    end
-
-    def handled_response=(val)
-      @handled_response = val
-    end
-
-    def handled_response
-      @handled_response || response
-    end
-
-    def inspect
-      result = ":method => #{self.method.inspect},\n" <<
-               "\t:url => #{URI.parse(self.url).to_s}"
-      if self.body and !self.body.empty?
-        result << ",\n\t:body => #{self.body.inspect}"
-      end
-
-      if self.params and !self.params.empty?
-        result << ",\n\t:params => #{self.params.inspect}"
+        @options[:headers] = {'User-Agent' => Typhoeus::USER_AGENT}
       end
-
-      if self.headers and !self.headers.empty?
-        result << ",\n\t:headers => #{self.headers.inspect}"
-      end
-
-      result
-    end
-
-    def cache_key
-      Digest::SHA1.hexdigest(cache_key_basis || url)
-    end
-
-    def self.run(url, params)
-      r = new(url, params)
-      Typhoeus::Hydra.hydra.queue r
-      Typhoeus::Hydra.hydra.run
-      r.response
+      @options[:verbose] = Typhoeus::Config.verbose unless @options[:verbose]
     end
 
-    def self.get(url, params = {})
-      run(url, params.merge(:method => :get))
-    end
-
-    def self.post(url, params = {})
-      run(url, params.merge(:method => :post))
-    end
-
-    def self.put(url, params = {})
-      run(url, params.merge(:method => :put))
+    # Returns wether other is equal to self.
+    #
+    # @example Are request equal?
+    #   request.eql?(other_request)
+    #
+    # @param [ Object ] other The object to check.
+    #
+    # @return [ Boolean ] Returns true if equals, else false.
+    def eql?(other)
+      self.class == other.class &&
+        self.url == other.url &&
+        fuzzy_hash_eql?(self.options, other.options)
     end
 
-    def self.delete(url, params = {})
-      run(url, params.merge(:method => :delete))
+    # Overrides Object#hash.
+    #
+    # @return [ Integer ] The integer representing the request.
+    def hash
+      [ self.class, self.url, self.options ].hash
     end
 
-    def self.head(url, params = {})
-      run(url, params.merge(:method => :head))
-    end
+    protected
 
-  protected
+    # Checks if two hashes are equal or not, discarding first-level hash order
+    #
+    # @param [ Hash ] hash
+    # @param [ Hash ] other hash to check for equality
+    #
+    # @return [ Boolean ] Returns true if hashes have same values for same keys and same length,
+    #     even if the keys are given in a different order.
+    def fuzzy_hash_eql?(left, right)
+      return true if (left == right)
 
-    # Return the important data needed to serialize this Request, except the
-    # `on_complete` and `after_complete` handlers, since they cannot be
-    # marshalled.
-    def marshal_dump
-      (instance_variables - ['@on_complete', '@after_complete', :@on_complete, :@after_complete]).map do |name|
-        [name, instance_variable_get(name)]
+      (left.count == right.count) && left.inject(true) do |res, kvp|
+        res && (kvp[1] == right[kvp[0]])
       end
     end
 
-    def marshal_load(attributes)
-      attributes.each { |name, value| instance_variable_set(name, value) }
-    end
-
-    def self.options
-      ACCESSOR_OPTIONS
-    end
-
-  private
-
-    def safe_to_i(value)
-      return value if value.is_a?(Fixnum)
-      return nil if value.nil?
-      return nil if value.respond_to?(:empty?) && value.empty?
-      value.to_i
-    end
   end
 end

data/lib/typhoeus/requests/actions.rb

@@ -0,0 +1,17 @@
+module Typhoeus
+  module Requests # :nodoc:
+
+    # Module containing logic about shortcuts to
+    # http methods. Like
+    #   Typhoeus.get("www.example.com")
+    module Actions
+      [:get, :post, :put, :delete, :head, :patch, :options].each do |name|
+        define_method(name) do |*args|
+          url = args[0]
+          options = args.fetch(1, {})
+          Request.run(url, options.merge(:method => name))
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/callbacks.rb

@@ -0,0 +1,48 @@
+module Typhoeus
+  module Requests
+
+    # This module contains the logic for the response callbacks.
+    # The on_complete callback is the only one at the moment.
+    #
+    # You can set multiple callbacks, which are then executed
+    # in the same order.
+    #
+    #   request.on_complete { p 1 }
+    #   request.on_complete { p 2 }
+    #   request.complete
+    #   #=> 1
+    #   #=> 2
+    #
+    # You can clear the callbacks:
+    #
+    #   request.on_complete { p 1 }
+    #   request.on_complete { p 2 }
+    #   request.on_complete.clear
+    #   request.on_complete
+    #   #=> []
+    module Callbacks
+
+      # Set on_complete callback.
+      #
+      # @example Set on_complete.
+      #   request.on_complete { p "yay" }
+      #
+      # @param [ Block ] block The block to execute.
+      def on_complete(&block)
+        @on_complete ||= []
+        @on_complete << block if block_given?
+        @on_complete
+      end
+
+      # Execute on_complete callbacks.
+      #
+      # @example Execute on_completes.
+      #   request.complete
+      def complete
+        if defined?(@on_complete)
+          @on_complete.map{ |callback| callback.call(self) }
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/marshal.rb

@@ -0,0 +1,21 @@
+module Typhoeus
+  module Requests
+
+    # This module contains custom serializer.
+    module Marshal
+
+      # Return the important data needed to serialize this Request, except the
+      # `on_complete` handler, since they cannot be marshalled.
+      def marshal_dump
+        (instance_variables - ['@on_complete', :@on_complete]).map do |name|
+          [name, instance_variable_get(name)]
+        end
+      end
+
+      # Load.
+      def marshal_load(attributes)
+        attributes.each { |name, value| instance_variable_set(name, value) }
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/memoizable.rb

@@ -0,0 +1,36 @@
+module Typhoeus
+  module Requests
+
+    # This module handles the GET request memoization
+    # on the request side. Memoization needs to be turned
+    # on:
+    #   Typhoeus.configre do |config|
+    #     config.memoize = true
+    #   end
+    module Memoizable
+
+      # Override response setter and memoizes response
+      # if the request is memoizable.
+      #
+      # @param [ Response ] response The response to set.
+      #
+      # @example Set response.
+      #   request.response = response
+      def response=(response)
+        hydra.memory[self] = response if memoizable?
+        super
+      end
+
+      # Return whether a request is memoizable.
+      #
+      # @example Is request memoizable?
+      #   request.memoizable?
+      #
+      # @return [ Boolean ] Return true if memoizable, false else.
+      def memoizable?
+        Typhoeus::Config.memoize &&
+          (options[:method].nil? || options[:method] == :get)
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/operations.rb

@@ -0,0 +1,51 @@
+module Typhoeus
+  module Requests
+
+    # This module contains everything what is necessary
+    # to make a single request.
+    module Operations
+
+      # :nodoc:
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods # :nodoc:
+
+        # Shortcut to perform a single request.
+        #
+        # @example Perform request.
+        #   Request.run("www.example.com")
+        #
+        # @param [ String ] url The url to request.
+        # @param [ Hash ] options The options hash.
+        #
+        # @return [ Response ] The response.
+        def run(url, options = {})
+          new(url, options).run
+        end
+      end
+
+      # Run a request.
+      #
+      # @example Run a request.
+      #  request.run
+      #
+      # @return [ Response ] The response.
+      def run
+        easy = Typhoeus.get_easy
+        easy.http_request(
+          url,
+          options.fetch(:method, :get),
+          options.reject{|k,_| k==:method}
+        )
+        easy.prepare
+        easy.perform
+        @response = Response.new(easy.to_hash)
+        Typhoeus.release_easy(easy)
+        complete
+        @response
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/responseable.rb

@@ -0,0 +1,29 @@
+module Typhoeus
+  module Requests
+
+    # This module contains logic for having a reponse
+    # getter and setter.
+    module Responseable
+
+      # Set the response.
+      #
+      # @example Set response.
+      #  request.response = response
+      #
+      # @param [ Response ] value The response to set.
+      def response=(value)
+        @response = value
+      end
+
+      # Return the response.
+      #
+      # @example Return response.
+      #   request.response
+      #
+      # @return [ Response ] The response.
+      def response
+        @response ||= nil
+      end
+    end
+  end
+end

data/lib/typhoeus/response.rb

@@ -1,123 +1,28 @@
-module Typhoeus
-  class Response
-    attr_accessor :request, :mock
-    attr_reader :code, :headers, :body, :time,
-                :requested_url, :requested_remote_method,
-                :requested_http_method, :start_time,
-                :effective_url, :start_transfer_time,
-                :app_connect_time, :pretransfer_time,
-                :connect_time, :name_lookup_time,
-                :curl_return_code, :curl_error_message,
-                :primary_ip, :redirect_count
-
-    attr_writer :headers_hash
-
-    def initialize(params = {})
-      @code                  = params[:code]
-      @curl_return_code      = params[:curl_return_code]
-      @curl_error_message    = params[:curl_error_message]
-      @status_message        = params[:status_message]
-      @http_version          = params[:http_version]
-      @headers               = params[:headers]
-      @body                  = params[:body]
-      @time                  = params[:time]
-      @requested_url         = params[:requested_url]
-      @requested_http_method = params[:requested_http_method]
-      @start_time            = params[:start_time]
-      @start_transfer_time   = params[:start_transfer_time]
-      @app_connect_time      = params[:app_connect_time]
-      @pretransfer_time      = params[:pretransfer_time]
-      @connect_time          = params[:connect_time]
-      @name_lookup_time      = params[:name_lookup_time]
-      @request               = params[:request]
-      @effective_url         = params[:effective_url]
-      @primary_ip            = params[:primary_ip]
-      @redirect_count        = params[:redirect_count]
-      @mock                  = params[:mock] || false  # default
-      @headers_hash          = Header.new(params[:headers_hash]) if params[:headers_hash]
-    end
-
-    # Returns true if this is a mock response.
-    def mock?
-      @mock
-    end
-
-    def headers
-      @headers ||= @headers_hash ? construct_header_string : ''
-    end
-
-    def headers_hash
-      @headers_hash ||= begin
-        headers.split("\n").map {|o| o.strip}.inject(Typhoeus::Header.new) do |hash, o|
-          if o.empty? || o =~ /^HTTP\/[\d\.]+/
-            hash
-          else
-            i = o.index(":") || o.size
-            key = o.slice(0, i)
-            value = o.slice(i + 1, o.size)
-            value = value.strip unless value.nil?
-            if hash.key? key
-              hash[key] = [hash[key], value].flatten
-            else
-              hash[key] = value
-            end
-
-            hash
-          end
-        end
-      end
-    end
-
-    def status_message
-      return @status_message if @status_message != nil
-
-      # HTTP servers can choose not to include the explanation to HTTP codes. The RFC
-      # states this (http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4):
-      # Except when responding to a HEAD request, the server SHOULD include an entity containing
-      # an explanation of the error situation [...]
-      # This means 'HTTP/1.1 404' is as valid as 'HTTP/1.1 404 Not Found' and we have to handle it.
+require 'typhoeus/responses/legacy'
+require 'typhoeus/responses/informations'
+require 'typhoeus/responses/status'
+require 'typhoeus/responses/header'
 
-      # Regexp doc: http://rubular.com/r/eAr1oVYsVa
-      if first_header_line != nil and first_header_line[/\d{3} (.*)$/, 1] != nil
-        @status_message = first_header_line[/\d{3} (.*)$/, 1].chomp
-      else
-        @status_message = nil
-      end
-    end
-
-    def http_version
-      @http_version ||= first_header_line ? first_header_line[/HTTP\/(\S+)/, 1] : nil
-    end
-
-    def success?
-      @code >= 200 && @code < 300
-    end
-
-    def modified?
-      @code != 304
-    end
+module Typhoeus
 
-    def timed_out?
-      curl_return_code == 28
+  # This class respresents the response.
+  class Response
+    include Responses::Status
+    include Responses::Informations
+    include Responses::Legacy
+
+    attr_accessor :request, :options
+
+    # Create a new response.
+    #
+    # @example Create a response.
+    #  Response.new
+    #
+    # @param [ Hash ] options The options hash.
+    #
+    # @return [ Response ] The new response.
+    def initialize(options = {})
+      @options = options
     end
-
-    private
-
-      def first_header_line
-        @first_header_line ||= @headers.to_s.split("\n").first
-      end
-
-      def construct_header_string
-        lines = ["HTTP/#{http_version} #{code} #{status_message}"]
-
-        @headers_hash.each do |key, values|
-          [values].flatten.each do |value|
-            lines << "#{key}: #{value}"
-          end
-        end
-
-        lines << '' << ''
-        lines.join("\r\n")
-      end
   end
 end