typhoeus 0.4.2 → 1.4.0

data/lib/typhoeus/request.rb

@@ -1,266 +1,221 @@
-require 'uri'
+require 'zlib'
+require 'digest/sha1'
+require 'typhoeus/request/actions'
+require 'typhoeus/request/before'
+require 'typhoeus/request/block_connection'
+require 'typhoeus/request/cacheable'
+require 'typhoeus/request/callbacks'
+require 'typhoeus/request/marshal'
+require 'typhoeus/request/memoizable'
+require 'typhoeus/request/operations'
+require 'typhoeus/request/responseable'
+require 'typhoeus/request/streamable'
+require 'typhoeus/request/stubbable'
 
 module Typhoeus
+
+  # This class represents a request.
+  #
+  # @example (see #initialize)
+  #
+  # @example Make a request with the shortcut.
+  #   response = Typhoeus.get("www.example.com")
+  #
+  # @see (see #initialize)
   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
-    ]
+    extend  Request::Actions
+    include Request::Callbacks::Types
+    include Request::Callbacks
+    include Request::Streamable
+    include Request::Marshal
+    include Request::Operations
+    include Request::Responseable
+    include Request::Memoizable
+    include Request::Cacheable
+    include Request::BlockConnection
+    include Request::Stubbable
+    include Request::Before
+
+    # Returns the provided base url.
+    #
+    # @return [ String ]
+    attr_accessor :base_url
 
-    attr_accessor *ACCESSOR_OPTIONS
+    # Returns options, which includes default parameters.
+    #
+    # @return [ Hash ]
+    attr_accessor :options
 
-    # Initialize a new Request
+    # Returns the hydra in which the request ran, if any.
     #
-    # 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
+    # @return [ Typhoeus::Hydra ]
     #
-    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] || {}
+    # @api private
+    attr_accessor :hydra
 
-      @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
+    # Returns the original options provided.
+    #
+    # @return [ Hash ]
+    #
+    # @api private
+    attr_accessor :original_options
 
-    LOCALHOST_ALIASES = %w[ localhost 127.0.0.1 0.0.0.0 ]
+    # @return [ Boolean ]
+    #
+    # @api private
+    attr_accessor :block_connection
 
-    def localhost?
-      LOCALHOST_ALIASES.include?(parsed_uri.host)
-    end
+    # Creates a new request.
+    #
+    # @example Simplest request.
+    #   response = Typhoeus::Request.new("www.example.com").run
+    #
+    # @example Request with url parameters.
+    #   response = Typhoeus::Request.new(
+    #     "www.example.com",
+    #     params: {a: 1}
+    #   ).run
+    #
+    # @example Request with a body.
+    #   response = Typhoeus::Request.new(
+    #     "www.example.com",
+    #     body: {b: 2}
+    #   ).run
+    #
+    # @example Request with parameters and body.
+    #   response = Typhoeus::Request.new(
+    #     "www.example.com",
+    #     params: {a: 1},
+    #     body: {b: 2}
+    #   ).run
+    #
+    # @example Create a request and allow follow redirections.
+    #   response = Typhoeus::Request.new(
+    #     "www.example.com",
+    #     followlocation: true
+    #   ).run
+    #
+    # @param [ String ] base_url The url to request.
+    # @param [ options ] options The options.
+    #
+    # @option options [ Hash ] :params Translated
+    #   into url parameters.
+    # @option options [ Hash ] :body Translated
+    #   into HTTP POST request body.
+    #
+    # @return [ Typhoeus::Request ] The request.
+    #
+    # @note See {http://rubydoc.info/github/typhoeus/ethon/Ethon/Easy/Options Ethon::Easy::Options} for more options.
+    #
+    # @see Typhoeus::Hydra
+    # @see Typhoeus::Response
+    # @see Typhoeus::Request::Actions
+    def initialize(base_url, options = {})
+      @base_url = base_url
+      @original_options = options
+      @options = options.dup
 
-    def user_agent
-      headers['User-Agent']
+      set_defaults
     end
 
+    # Return the url.
+    # In contrast to base_url which returns the value you specified, url returns
+    # the full url including the parameters.
+    #
+    # @example Get the url.
+    #   request.url
+    #
+    # @since 0.5.5
     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)
-      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
+      easy = EasyFactory.new(self).get
+      url = easy.url
+      Typhoeus::Pool.release(easy)
+      url
     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
+    # Returns whether 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 equal, else false.
+    #
+    # @api private
+    def eql?(other)
+      self.class == other.class &&
+        self.base_url == other.base_url &&
+        fuzzy_hash_eql?(self.options, other.options)
     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}"
-      end
-
-      if self.headers and !self.headers.empty?
-        result << ",\n\t:headers => #{self.headers.inspect}"
-      end
-
-      result
+    # Overrides Object#hash.
+    #
+    # @return [ Integer ] The integer representing the request.
+    #
+    # @api private
+    def hash
+      Zlib.crc32 cache_key
     end
 
+    # Returns a cache key for use with caching methods that required a string
+    # for a key. Will get used by ActiveSupport::Cache stores automatically.
+    #
+    # @return [ String ] The cache key.
     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
-    end
-
-    def self.get(url, params = {})
-      run(url, params.merge(:method => :get))
+      Digest::SHA1.hexdigest "#{self.class.name}#{base_url}#{hashable_string_for(options)}"
     end
 
-    def self.post(url, params = {})
-      run(url, params.merge(:method => :post))
-    end
-
-    def self.put(url, params = {})
-      run(url, params.merge(:method => :put))
-    end
-
-    def self.delete(url, params = {})
-      run(url, params.merge(:method => :delete))
-    end
-
-    def self.head(url, params = {})
-      run(url, params.merge(:method => :head))
+    # Mimics libcurls POST body generation. This is not accurate, but good
+    # enough for VCR.
+    #
+    # @return [ String ] The encoded body.
+    #   otherwise.
+    #
+    # @api private
+    def encoded_body
+      Ethon::Easy::Form.new(nil, options[:body]).to_s
     end
 
-  protected
+    private
 
-    # 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)]
+    # Checks if two hashes are equal or not, discarding
+    # first-level hash order.
+    #
+    # @param [ Hash ] left
+    # @param [ Hash ] right 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)
+
+      (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
+    def hashable_string_for(obj)
+      case obj
+      when Hash
+        hashable_string_for(obj.sort_by {|sub_obj| sub_obj.first.to_s})
+      when Array
+        obj.map {|sub_obj| hashable_string_for(sub_obj)}.to_s
+      else
+        obj.to_s
+      end
     end
 
-  private
+    # Sets default header and verbose when turned on.
+    def set_defaults
+      default_user_agent = Config.user_agent || Typhoeus::USER_AGENT
 
-    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
+      options[:headers] = {'User-Agent' => default_user_agent}.merge(options[:headers] || {})
+      options[:headers]['Expect'] ||= ''
+      options[:verbose] = Typhoeus::Config.verbose if options[:verbose].nil? && !Typhoeus::Config.verbose.nil?
+      options[:maxredirs] ||= 50
+      options[:proxy] = Typhoeus::Config.proxy unless options.has_key?(:proxy) || Typhoeus::Config.proxy.nil?
     end
   end
 end

data/lib/typhoeus/response/cacheable.rb

@@ -0,0 +1,14 @@
+module Typhoeus
+  class Response
+    module Cacheable
+
+      # Set the cache status, if we got response from cache
+      # it will have cached? == true
+      attr_writer :cached
+
+      def cached?
+        defined?(@cached) ? !!@cached : false
+      end
+    end
+  end
+end

data/lib/typhoeus/response/header.rb

@@ -0,0 +1,105 @@
+require 'delegate'
+
+module Typhoeus
+  class Response
+
+    # This class represents the response header.
+    # It can be accessed like a hash.
+    # Values can be strings (normal case) or arrays of strings (for duplicates headers)
+    #
+    # @api private
+    class Header < DelegateClass(Hash)
+
+      # Create a new header.
+      #
+      # @example Create new header.
+      #   Header.new(raw)
+      #
+      # @param [ String ] raw The raw header.
+      def initialize(raw)
+        super({})
+        @raw = raw
+        @sanitized = {}
+        parse
+      end
+
+      def [](key)
+        fetch(key) { @sanitized[key.to_s.downcase] }
+      end
+
+      # Parses the raw header.
+      #
+      # @example Parse header.
+      #   header.parse
+      def parse
+        case @raw
+        when Hash
+          raw.each do |k, v|
+            process_pair(k, v)
+          end
+        when String
+          raw.split(/\r?\n(?!\s)/).each do |header|
+            header.strip!
+            next if header.empty? || header.start_with?( 'HTTP/' )
+            process_line(header)
+          end
+        end
+      end
+
+      private
+
+      # Processes line and saves the result.
+      #
+      # @return [ void ]
+      def process_line(header)
+        key, value = header.split(':', 2)
+        process_pair(key.strip, (value ? value.strip.gsub(/\r?\n\s*/, ' ') : ''))
+      end
+
+      # Sets key value pair for self and @sanitized.
+      #
+      # @return [ void ]
+      def process_pair(key, value)
+        set_value(key, value, self)
+        @sanitized[key.downcase] = self[key]
+      end
+
+      # Sets value for key in specified hash
+      #
+      # @return [ void ]
+      def set_value(key, value, hash)
+        current_value = hash[key]
+        if current_value
+          if current_value.is_a? Array
+            current_value << value
+          else
+            hash[key] = [current_value, value]
+          end
+        else
+          hash[key] = value
+        end
+      end
+
+      # Returns the raw header or empty string.
+      #
+      # @example Return raw header.
+      #   header.raw
+      #
+      # @return [ String ] The raw header.
+      def raw
+        @raw || ''
+      end
+
+      # Sets the default proc for the specified hash independent of the Ruby version.
+      #
+      # @return [ void ]
+      def set_default_proc_on(hash, default_proc)
+        if hash.respond_to?(:default_proc=)
+          hash.default_proc = default_proc
+        else
+          hash.replace(Hash.new(&default_proc).merge(hash))
+        end
+      end
+    end
+  end
+end