typhoeus 0.4.2 → 0.5.0.rc

data/lib/typhoeus/response/informations.rb

@@ -0,0 +1,205 @@
+module Typhoeus
+  class Response
+
+    # This module contains logic about informations
+    # on a response.
+    module Informations
+
+      # Return libcurls return value.
+      #
+      # @example Get return_code.
+      #   response.return_code
+      #
+      # @return [ Symbol ] The return_code.
+      def return_code
+        options[:return_code]
+      end
+
+      # Return the http response body.
+      #
+      # @example Get response_body.
+      #   response.response_body
+      #
+      # @return [ String ] The response_body.
+      def response_body
+        options[:response_body] || options[:body]
+      end
+      alias :body :response_body
+
+      # Return the http response headers.
+      #
+      # @example Get response_headers.
+      #   response.response_headers
+      #
+      # @return [ String ] The response_headers.
+      def response_headers
+        options[:response_headers]
+      end
+
+      # Return the last received HTTP, FTP or SMTP response code.
+      # The value will be zero if no server response code has
+      # been received. Note that a proxy's CONNECT response should
+      # be read with http_connect_code and not this.
+      #
+      # @example Get response_code.
+      #   response.response_code
+      #
+      # @return [ Integer ] The response_code.
+      def response_code
+        options[:response_code] || options[:code]
+      end
+      alias :code :response_code
+
+      # Return the available http auth methods.
+      # Bitmask indicating the authentication method(s)
+      # available.
+      #
+      # @example Get httpauth_avail.
+      #   response.httpauth_avail
+      #
+      # @return [ Integer ] The bitmask.
+      def httpauth_avail
+        options[:httpauth_avail]
+      end
+
+
+      # Return the total time in seconds for the previous
+      # transfer, including name resolving, TCP connect etc.
+      #
+      # @example Get total_time.
+      #   response.total_time
+      #
+      # @return [ Float ] The total_time.
+      def total_time
+        options[:total_time] || options[:time]
+      end
+      alias :time :total_time
+
+      # Return the time, in seconds, it took from the start
+      # until the first byte is received by libcurl. This
+      # includes pretransfer time and also the time the
+      # server needs to calculate the result.
+      #
+      # @example Get starttransfer_time.
+      #   response.starttransfer_time
+      #
+      # @return [ Float ] The starttransfer_time.
+      def starttransfer_time
+        options[:starttransfer_time] || options[:start_transfer_time]
+      end
+      alias :start_transfer_time :starttransfer_time
+
+      # Return the time, in seconds, it took from the start
+      # until the SSL/SSH connect/handshake to the remote
+      # host was completed. This time is most often very near
+      # to the pre transfer time, except for cases such as HTTP
+      # pippelining where the pretransfer time can be delayed
+      # due to waits in line for the pipeline and more.
+      #
+      # @example Get appconnect_time.
+      #   response.appconnect_time
+      #
+      # @return [ Float ] The appconnect_time.
+      def appconnect_time
+        options[:appconnect_time] || options[:app_connect_time]
+      end
+      alias :app_connect_time :appconnect_time
+
+      # Return the time, in seconds, it took from the start
+      # until the file transfer is just about to begin. This
+      # includes all pre-transfer commands and negotiations
+      # that are specific to the particular protocol(s) involved.
+      # It does not involve the sending of the protocol-
+      # specific request that triggers a transfer.
+      #
+      # @example Get pretransfer_time.
+      #  response.pretransfer_time
+      #
+      # @return [ Float ] The pretransfer_time.
+      def pretransfer_time
+        options[:pretransfer_time]
+      end
+
+      # Return the time, in seconds, it took from the start
+      # until the connect to the remote host (or proxy) was completed.
+      #
+      # @example Get connect_time.
+      #   response.connect_time
+      #
+      # @return [ Float ] The connect_time.
+      def connect_time
+        options[:connect_time]
+      end
+
+      # Return the time, in seconds, it took from the
+      # start until the name resolving was completed.
+      #
+      # @example Get namelookup_time.
+      #   response.namelookup_time
+      #
+      # @return [ Float ] The namelookup_time.
+      def namelookup_time
+        options[:namelookup_time] || options[:name_lookup_time]
+      end
+      alias :name_lookup_time :namelookup_time
+
+      # Return the last used effective url.
+      #
+      # @example Get effective_url.
+      #   response.effective_url
+      #
+      # @return [ String ] The effective_url.
+      def effective_url
+        options[:effective_url]
+      end
+
+      # Return the string holding the IP address of the most recent
+      # connection done with this curl handle. This string
+      # may be IPv6 if that's enabled.
+      #
+      # @example Get primary_ip.
+      #   response.primary_ip
+      #
+      # @return [ String ] The primary_ip.
+      def primary_ip
+        options[:primary_ip]
+      end
+
+      # Return the total number of redirections that were
+      # actually followed
+      #
+      # @example Get redirect_count.
+      #   response.redirect_count
+      #
+      # @return [ Integer ] The redirect_count.
+      def redirect_count
+        options[:redirect_count]
+      end
+
+      # Returns the response header.
+      #
+      # @example Return headers.
+      #   response.headers
+      #
+      # @return [ Typhoeus::Header ] The response header.
+      def headers
+        return nil if response_headers.nil? && @headers.nil?
+        @headers ||= Response::Header.new(response_headers.split("\r\n\r\n").last)
+      end
+      alias :headers_hash :headers
+
+      # Return all redirections in between as multiple
+      # responses with header.
+      #
+      # @example Return redirections.
+      #   response.redirections
+      #
+      # @return [ Array<Typhoeus::Response> ] The redirections
+      def redirections
+        return [] unless response_headers
+        response_headers.split("\r\n\r\n")[0..-2].map{ |h| Response.new(:response_headers => h) }
+      end
+    end
+  end
+end
+

data/lib/typhoeus/response/status.rb

@@ -0,0 +1,80 @@
+module Typhoeus
+  class Response
+
+    # This module contains logic about the http
+    # status.
+    module Status
+
+      # Return the status message if present.
+      #
+      # @example Return status message.
+      #   reesponse.status_message
+      #
+      # @return [ String ] The message.
+      def status_message
+        return @status_message if defined?(@status_message) && @status_message
+        return options[:status_message] unless options[: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.
+
+        # 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
+
+      # Return the http version.
+      #
+      # @example Return http version.
+      #  response.http_version
+      #
+      # @return [ String ] The http version.
+      def http_version
+        @http_version ||= first_header_line ? first_header_line[/HTTP\/(\S+)/, 1] : nil
+      end
+
+      # Return wether the response is a success.
+      #
+      # @example Return if the response was successful.
+      #  response.success?
+      #
+      # @return [ Boolean ] Return true if successful, false else.
+      def success?
+        return_code == :ok && response_code >= 200 && response_code < 300
+      end
+
+      # Return wether the response is modified.
+      #
+      # @example Return if the response was modified.
+      #  response.modified?
+      #
+      # @return [ Boolean ] Return true if modified, false else.
+      def modified?
+        return_code == :ok && response_code != 304
+      end
+
+      # Return wether the response is timed out.
+      #
+      # @example Return if the response timed out.
+      #  response.timed_out?
+      #
+      # @return [ Boolean ] Return true if timed out, false else.
+      def timed_out?
+        [:operation_timedout, :couldnt_connect].include?(return_code)
+      end
+
+      private
+
+      # :nodoc:
+      def first_header_line
+        @first_header_line ||= response_headers.to_s.split("\n").first
+      end
+    end
+  end
+end

data/lib/typhoeus/response.rb

@@ -1,123 +1,50 @@
-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/response/header'
+require 'typhoeus/response/informations'
+require 'typhoeus/response/status'
 
-      # 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 Response::Informations
+    include Response::Status
+
+    # Remembers the corresponding request.
+    #
+    # @example Get request.
+    #   request = Typhoeus::Request.get("www.example.com")
+    #   response = request.run
+    #   response == request.response
+    #   #=> true
+    #
+    # @return [ Typhoeus::Request ]
+    attr_accessor :request
+
+    # The options provided, contains all the
+    # informations about the request.
+    #
+    # @return [ Hash ]
+    attr_accessor :options
+
+    # @api private
+    attr_writer :mock
+
+    # 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
+      @headers = options[:headers]
+    end
+
+    # @api private
+    def mock
+      defined?(@mock) ? @mock : options[:mock]
     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

data/lib/typhoeus/version.rb

@@ -1,3 +1,5 @@
 module Typhoeus
-  VERSION = '0.4.2'
+
+  # The current Typhoeus version.
+  VERSION = '0.5.0.rc'
 end

data/lib/typhoeus.rb

@@ -1,56 +1,104 @@
 require 'digest/sha2'
+require 'ethon'
 
-require 'typhoeus/utils'
-require 'typhoeus/header'
-require 'typhoeus/curl'
-require 'typhoeus/easy'
-require 'typhoeus/form'
-require 'typhoeus/multi'
-require 'typhoeus/filter'
-require 'typhoeus/param_processor'
-require 'typhoeus/remote'
-require 'typhoeus/remote_proxy_object'
-require 'typhoeus/response'
-require 'typhoeus/request'
+require 'typhoeus/config'
+require 'typhoeus/errors'
+require 'typhoeus/expectation'
 require 'typhoeus/hydra'
-require 'typhoeus/hydra_mock'
+require 'typhoeus/request'
+require 'typhoeus/response'
 require 'typhoeus/version'
 
+# Typhoeus is a http client library based on Ethon which
+# wraps libcurl.
+#
+# @example (see Typhoeus::Request)
+# @example (see Typhoeus::Hydra)
+#
+# @see Typhoeus::Request
+# @see Typhoeus::Hydra
+#
+# @since 0.5.0
 module Typhoeus
-  def self.easy_object_pool
-    @easy_objects ||= []
-  end
+  extend self
+  extend Hydra::EasyPool
+  extend Request::Actions
+  extend Request::Callbacks::Types
 
-  def self.init_easy_object_pool
-    20.times do
-      easy_object_pool << Typhoeus::Easy.new
-    end
-  end
+  # The default typhoeus user agent.
+  USER_AGENT = "Typhoeus - https://github.com/typhoeus/typhoeus"
 
-  def self.release_easy_object(easy)
-    easy.reset
-    easy_object_pool << easy
+  # Set the Typhoeus configuration options by passing a block.
+  #
+  # @example (see Typhoeus::Config)
+  #
+  # @yield [ Typhoeus::Config ]
+  #
+  # @return [ Typhoeus::Config ] The configuration.
+  #
+  # @see Typhoeus::Config
+  def configure
+    yield Config
   end
 
-  def self.get_easy_object
-    if easy_object_pool.empty?
-      Typhoeus::Easy.new
-    else
-      easy_object_pool.pop
+  # Stub out specific request.
+  #
+  # @example (see Typhoeus::Expectation)
+  #
+  # @param [ String ] url The url to stub out.
+  # @param [ Hash ] options The options to stub out.
+  #
+  # @return [ Typhoeus::Expectation ] The expecatation.
+  #
+  # @see Typhoeus::Expectation
+  def stub(url, options = {})
+    expectation = Expectation.all.find{ |e| e.url == url && e.options == options }
+    return expectation if expectation
+
+    Expectation.new(url, options).tap do |new_expectation|
+      Expectation.all << new_expectation
     end
   end
 
-  def self.add_easy_request(easy_object)
-    Thread.current[:curl_multi] ||= Typhoeus::Multi.new
-    Thread.current[:curl_multi].add(easy_object)
+  # Add before callbacks.
+  #
+  # @example Add before callback.
+  #   Typhoeus.before { |request| p request.url }
+  #
+  # @param [ Block ] block The callback.
+  #
+  # @yield [ Typhoeus::Request ]
+  #
+  # @return [ Array<Block> ] All before blocks.
+  def before(&block)
+    @before ||= []
+    @before << block if block_given?
+    @before
   end
 
-  def self.perform_easy_requests
-    multi = Thread.current[:curl_multi]
-    start_time = Time.now
-    multi.easy_handles.each do |easy|
-      easy.start_time = start_time
-    end
-    multi.perform
+  # Execute given block as if block connection is turned off.
+  # The old block connection state is restored afterwards.
+  #
+  # @example Make a real request, no matter if its blocked.
+  #   Typhoeus::Config.block_connection = true
+  #   Typhoeus.get("www.example.com").code
+  #   #=> raise Typhoeus::Errors::NoStub
+  #
+  #   Typhoeus.with_connection do
+  #     Typhoeus.get("www.example.com").code
+  #     #=> :ok
+  #   end
+  #
+  # @param [ Block ] block The block to execute.
+  #
+  # @return [ Object ] Returns the return value of block.
+  #
+  # @see Typhoeus::Config#block_connection
+  def with_connection
+    old = Config.block_connection
+    Config.block_connection = false
+    result = yield if block_given?
+    Config.block_connection = old
+    result
   end
 end