typhoeus 0.4.2 → 0.5.0.alpha

data/lib/typhoeus/hydras/block_connection.rb

@@ -0,0 +1,33 @@
+module Typhoeus
+  module Hydras
+
+    # This module handles the blocked connection request mode on
+    # the hydra side, where only stubbed requests
+    # are allowed.
+    # Connection blocking needs to be turned on:
+    #   Typhoeus.configure do |config|
+    #     config.block_connection = true
+    #   end
+    #
+    # When trying to do real requests a NoStub error
+    # is raised.
+    module BlockConnection
+
+      # Overrides queue in order to check before if block connection
+      # is turned on. If thats the case a NoStub error is
+      # raised.
+      #
+      # @example Queue the request.
+      #   hydra.queue(request)
+      #
+      # @param [ Request ] request The request to enqueue.
+      def queue(request)
+        if Typhoeus::Config.block_connection
+          raise Typhoeus::Errors::NoStub.new(request)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/hydras/easy_factory.rb

@@ -0,0 +1,67 @@
+module Typhoeus
+  module Hydras
+
+    # This is a Factory for easies to be used in the hydra.
+    # Before an easy is ready to be added to a multi, it needs
+    # to be prepared and the on_complete callback to be set.
+    # This is done by this class.
+    class EasyFactory
+      attr_reader :request, :hydra
+
+      # Create an easy factory.
+      #
+      # @example Create easy factory.
+      #   Typhoeus::Hydras::EasyFactory.new(request, hydra)
+      #
+      # @param [ Request ] request The request to build an easy for.
+      # @param [ Hydra ] hydra The hydra to build an easy for.
+      def initialize(request, hydra)
+        @request = request
+        @hydra = hydra
+      end
+
+      # Return the easy in question.
+      #
+      # @example Return easy.
+      #   easy_factory.easy
+      #
+      # @return [ Ethon::Easy ] The easy.
+      def easy
+        @easy ||= hydra.get_easy
+      end
+
+      # Fabricated and prepared easy.
+      #
+      # @example Prepared easy.
+      #   easy_factory.get
+      #
+      # @return [ Ethon::Easy ] The prepared easy.
+      def get
+        easy.http_request(
+          request.url,
+          request.options.fetch(:method, :get),
+          request.options.reject{|k,_| k==:method}
+        )
+        easy.prepare
+        set_callback
+        easy
+      end
+
+      # Sets on_complete callback on easy in order to be able to
+      # track progress.
+      #
+      # @example Set callback.
+      #   easy_factory.set_callback
+      #
+      # @return [ Ethon::Easy ] The easy.
+      def set_callback
+        easy.on_complete do |easy|
+          request.response = Response.new(easy.to_hash)
+          hydra.release_easy(easy)
+          hydra.queue(hydra.queued_requests.shift) unless hydra.queued_requests.empty?
+          request.execute_callbacks
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/hydras/easy_pool.rb

@@ -0,0 +1,40 @@
+module Typhoeus
+  module Hydras
+
+    # The easy pool stores already initialized
+    # easy handles for future use. This is useful
+    # because creating them is quite expensive.
+    module EasyPool
+
+      # Return the easy pool.
+      #
+      # @example Return easy pool.
+      #   hydra.easy_pool
+      #
+      # @return [ Array ] The easy pool.
+      def easy_pool
+        @easy_pool ||= []
+      end
+
+      # Releases easy into pool. The easy handle is
+      # resetted before it gets back in.
+      #
+      # @example Release easy.
+      #   hydra.release_easy(easy)
+      def release_easy(easy)
+        easy.reset
+        easy_pool << easy
+      end
+
+      # Return an easy from pool.
+      #
+      # @example Return easy.
+      #   hydra.get_easy
+      #
+      # @return [ Ethon::Easy ] The easy.
+      def get_easy
+        easy_pool.pop || Ethon::Easy.new
+      end
+    end
+  end
+end

data/lib/typhoeus/hydras/memoizable.rb

@@ -0,0 +1,53 @@
+module Typhoeus
+  module Hydras
+
+    # This module handles the GET request memoization
+    # on the hydra side. Memoization needs to be turned
+    # on:
+    #   Typhoeus.configure do |config|
+    #     config.memoize = true
+    #   end
+    module Memoizable
+
+      # Return the memory.
+      #
+      # @example Return the memory.
+      #   hydra.memory
+      #
+      # @return [ Hash ] The memory.
+      def memory
+        @memory ||= {}
+      end
+
+      # Overrides queue in order to check before if request
+      # is memoizable and already in memory. If thats the case,
+      # super is not called, instead the response is set and
+      # the on_complete callback called.
+      #
+      # @example Queue the request.
+      #   hydra.queue(request)
+      #
+      # @param [ Request ] request The request to enqueue.
+      #
+      # @return [ Request ] The queued request.
+      def queue(request)
+        if request.memoizable? && memory.has_key?(request)
+          request.instance_variable_set(:@response, memory[request])
+          request.execute_callbacks
+        else
+          super
+        end
+      end
+
+      # Overrides run to make sure the memory is cleared after
+      # each run.
+      #
+      # @example Run hydra.
+      #   hydra.run
+      def run
+        super
+        memory.clear
+      end
+    end
+  end
+end

data/lib/typhoeus/hydras/queueable.rb

@@ -0,0 +1,46 @@
+module Typhoeus
+  module Hydras # :nodoc:
+
+    # This module handles the request queueing on
+    # hydra.
+    module Queueable
+
+      # Return the queued requests.
+      #
+      # @example Return queued requests.
+      #  hydra.queued_requests
+      #
+      # @return [ Array ] The queued requests.
+      def queued_requests
+        @queued_requests ||= []
+      end
+
+      # Abort the current hydra run as good as
+      # possible. This means that it only
+      # clears the queued requests and can't do
+      # anything about already running requests.
+      #
+      # @example Abort hydra.
+      #  hydra.abort
+      def abort
+        queued_requests.clear
+      end
+
+      # Enqueues a request in order to be performed
+      # by the hydra. This can even be done while
+      # the hydra is running. Also sets hydra on
+      # request.
+      #
+      # @example Queue request.
+      #  hydra.queue(request)
+      def queue(request)
+        request.hydra = self
+        if multi.easy_handles.size < max_concurrency
+          multi.add(Hydras::EasyFactory.new(request, self).get)
+        else
+          queued_requests << request
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/hydras/runnable.rb

@@ -0,0 +1,18 @@
+module Typhoeus
+  module Hydras
+
+    # This module contains logic to run a hydra.
+    module Runnable
+
+      # Start the hydra run.
+      #
+      # @example Start hydra run.
+      #   hydra.run
+      #
+      # @return [ Symbol ] Return value from multi.perform.
+      def run
+        multi.perform
+      end
+    end
+  end
+end

data/lib/typhoeus/hydras/stubbable.rb

@@ -0,0 +1,27 @@
+module Typhoeus
+  module Hydras
+
+    # This module handles stubbing on the hydra side.
+    # It plays well with the block_connection configuration,
+    # which raises when you make a request which is not stubbed.
+    module Stubbable
+
+      # Override queue in order to check for matching expecations.
+      # When an expecation is found, super is not called. Instead a
+      # canned response is assigned to the request.
+      #
+      # @example Queue the request.
+      #   hydra.queue(request)
+      def queue(request)
+        if expectation = Expectation.find_by(request)
+          request.response = expectation.response
+          request.response.mock = true
+          request.execute_callbacks
+          request.response
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/request.rb

@@ -1,266 +1,91 @@
-require 'uri'
+require 'typhoeus/requests/actions'
+require 'typhoeus/requests/block_connection'
+require 'typhoeus/requests/callbacks'
+require 'typhoeus/requests/marshal'
+require 'typhoeus/requests/memoizable'
+require 'typhoeus/requests/operations'
+require 'typhoeus/requests/responseable'
+require 'typhoeus/requests/stubbable'
 
 module Typhoeus
-  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
-    ]
-
-    attr_accessor *ACCESSOR_OPTIONS
 
-    # Initialize a new Request
+  # This class represents a request.
+  class Request
+    extend  Requests::Actions
+    include Requests::Callbacks::Types
+    include Requests::Callbacks
+    include Requests::Marshal
+    include Requests::Operations
+    include Requests::Responseable
+    include Requests::Memoizable
+    include Requests::BlockConnection
+    include Requests::Stubbable
+
+    attr_accessor :options, :url, :hydra, :original_options
+
+    # Create a new request.
     #
-    # 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
+    # @example Create a request.
+    #   Request.new("www.example.com")
     #
+    # @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
-
-    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
+      @original_options = options
+      @options = options.dup
 
-    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
-    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
+      set_defaults
     end
 
-    def call_after_complete
-      @after_complete.call(@handled_response) if @after_complete
-    end
-
-    def handled_response=(val)
-      @handled_response = val
+    # 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 handled_response
-      @handled_response || response
+    # Overrides Object#hash.
+    #
+    # @return [ Integer ] The integer representing the request.
+    def hash
+      [ self.class, self.url, self.options ].hash
     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
+    protected
 
-      if self.params and !self.params.empty?
-        result << ",\n\t:params => #{self.params.inspect}"
-      end
+    # 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)
 
-      if self.headers and !self.headers.empty?
-        result << ",\n\t:headers => #{self.headers.inspect}"
+      (left.count == right.count) && left.inject(true) do |res, kvp|
+        res && (kvp[1] == right[kvp[0]])
       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
-    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))
-    end
-
-    def self.delete(url, params = {})
-      run(url, params.merge(:method => :delete))
-    end
-
-    def self.head(url, params = {})
-      run(url, params.merge(:method => :head))
-    end
-
-  protected
-
-    # 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)]
+    # Sets default header and verbose when turned on.
+    def set_defaults
+      if @options[:headers]
+        @options[:headers] = {'User-Agent' => Typhoeus::USER_AGENT}.merge(options[:headers])
+      else
+        @options[:headers] = {'User-Agent' => Typhoeus::USER_AGENT}
       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
+      @options[:verbose] = Typhoeus::Config.verbose if @options[:verbose].nil? && !Typhoeus::Config.verbose.nil?
     end
   end
 end