typhoeus 0.4.2 → 1.4.0

data/lib/typhoeus/response/informations.rb

@@ -0,0 +1,248 @@
+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
+
+      # Returns a string describing the return.
+      #
+      # @example Get return_message.
+      #   response.return_message
+      #
+      # @return [ String ] The return_message.
+      #
+      # @since 0.6.2
+      def return_message
+        Ethon::Curl.easy_strerror(return_code) if 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
+        return options[:response_headers] if options[:response_headers]
+        if mock? && h = options[:headers]
+            status_code = return_code || "200"
+            reason_phrase = status_code == "200" ? "OK" : "Mock Reason Phrase"
+            status_line = "HTTP/1.1 #{status_code} #{reason_phrase}"
+            actual_headers = h.map{ |k,v| [k, v.respond_to?(:join) ? v.join(',') : v] }.
+              map{ |e| "#{e.first}: #{e.last}" }
+
+            [status_line, *actual_headers].join("\r\n")
+        end
+      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]).to_i
+      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
+      # pipelining 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 time, in seconds, it took for all redirection steps
+      # include name lookup, connect, pretransfer and transfer before the
+      # final transaction was started. time_redirect shows the complete
+      # execution time for multiple redirections.
+      #
+      # @example Get redirect_time.
+      #   response.redirect_time
+      #
+      # @return [ Float ] The redirect_time.
+      def redirect_time
+        options[:redirect_time]
+      end
+
+      # 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
+
+      def request_size
+        options[:request_size]
+      end
+
+      def debug_info
+        options[:debug_info]
+      end
+
+      # Returns the response header.
+      #
+      # @example Return headers.
+      #   response.headers
+      #
+      # @return [ Typhoeus::Header ] The response header.
+      def headers
+        return Header.new(options[:headers]) if mock? && options[:headers]
+        return nil if response_headers.nil? && !defined?(@headers)
+        @headers ||= 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,106 @@
+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 whether the response is a success.
+      #
+      # @example Return if the response was successful.
+      #  response.success?
+      #
+      # @return [ Boolean ] Return true if successful, false else.
+      def success?
+        (mock || return_code == :ok) && response_code && has_good_response_code?
+      end
+
+      # Return whether the response is a failure.
+      #
+      # @example Return if the response was failed.
+      #  response.failure?
+      #
+      # @return [ Boolean ] Return true if failure, false else.
+      def failure?
+        (mock || return_code == :internal_server_error) && response_code && has_bad_response_code?
+      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?
+        (mock || return_code == :ok) && response_code && response_code != 304
+      end
+
+      # Return whether 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?
+        return_code == :operation_timedout
+      end
+
+      private
+
+      # :nodoc:
+      def first_header_line
+        @first_header_line ||= begin
+          if response_headers.to_s.include?("\r\n\r\n")
+            response_headers.to_s.split("\r\n\r\n").last.split("\r\n").first
+          else
+            response_headers.to_s.split("\r\n").first
+          end
+        end
+      end
+
+      # :nodoc:
+      def has_good_response_code?
+        response_code >= 200 && response_code < 300
+      end
+
+      # :nodoc:
+      def has_bad_response_code?
+        !has_good_response_code?
+      end
+    end
+  end
+end

data/lib/typhoeus/response.rb

@@ -1,123 +1,68 @@
-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
+require 'typhoeus/response/header'
+require 'typhoeus/response/informations'
+require 'typhoeus/response/status'
+require 'typhoeus/response/cacheable'
 
-      # 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
-
-    def http_version
-      @http_version ||= first_header_line ? first_header_line[/HTTP\/(\S+)/, 1] : nil
-    end
+module Typhoeus
 
-    def success?
-      @code >= 200 && @code < 300
+  # This class represents the response.
+  class Response
+    include Response::Informations
+    include Response::Status
+    include Response::Cacheable
+
+    # Remembers the corresponding request.
+    #
+    # @example Get request.
+    #   request = Typhoeus::Request.new("www.example.com")
+    #   response = request.run
+    #   request == response.request
+    #   #=> true
+    #
+    # @return [ Typhoeus::Request ]
+    attr_accessor :request
+
+    # The provided options, which contain all the
+    # informations about the request.
+    #
+    # @return [ Hash ]
+    attr_accessor :options
+
+    # Set the handled response.
+    attr_writer :handled_response
+
+    # @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 = Header.new(options[:headers]) if options[:headers]
     end
 
-    def modified?
-      @code != 304
+    # Returns whether this request is mocked
+    # or not.
+    #
+    # @api private
+    def mock
+      defined?(@mock) ? @mock : options[:mock]
     end
-
-    def timed_out?
-      curl_return_code == 28
+    alias :mock? :mock
+
+    # Returns the handled_response if it has
+    # been defined; otherwise, returns the response
+    #
+    # @return [ Object ] The result of callbacks
+    #   done on the response or the original response.
+    def handled_response
+      @handled_response || self
     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 = '1.4.0'
 end