typhoeus 0.4.2 → 0.5.0.alpha

data/lib/typhoeus/requests/actions.rb

@@ -0,0 +1,101 @@
+module Typhoeus
+  module Requests # :nodoc:
+
+    # Module containing logic about shortcuts to
+    # http methods. Like
+    #   Typhoeus.get("www.example.com")
+    module Actions
+
+      # Make a get request.
+      #
+      # @example Make get request.
+      #   Typhoeus.get("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def get(url, options = {})
+        Request.run(url, options.merge(:method => :get))
+      end
+
+      # Make a post request.
+      #
+      # @example Make post request.
+      #   Typhoeus.post("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def post(url, options = {})
+        Request.run(url, options.merge(:method => :post))
+      end
+
+      # Make a put request.
+      #
+      # @example Make put request.
+      #   Typhoeus.put("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def put(url, options = {})
+        Request.run(url, options.merge(:method => :put))
+      end
+
+      # Make a delete request.
+      #
+      # @example Make delete request.
+      #   Typhoeus.delete("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def delete(url, options = {})
+        Request.run(url, options.merge(:method => :delete))
+      end
+
+      # Make a head request.
+      #
+      # @example Make head request.
+      #   Typhoeus.head("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def head(url, options = {})
+        Request.run(url, options.merge(:method => :head))
+      end
+
+      # Make a patch request.
+      #
+      # @example Make patch request.
+      #   Typhoeus.patch("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def patch(url, options = {})
+        Request.run(url, options.merge(:method => :patch))
+      end
+
+      # Make a options request.
+      #
+      # @example Make options request.
+      #   Typhoeus.options("www.example.com")
+      #
+      # @param [ String ] url The url to request.
+      # @param [ options ] options The options.
+      #
+      # @return [ Response ] The response.
+      def options(url, options = {})
+        Request.run(url, options.merge(:method => :options))
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/block_connection.rb

@@ -0,0 +1,31 @@
+module Typhoeus
+  module Requests
+
+    # This module handles the blocked connection request mode on
+    # the request 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 run in order to check before if block connection
+      # is turned on. If thats the case a NoStub error is
+      # raised.
+      #
+      # @example Run request.
+      #   request.run
+      def run
+        if Typhoeus::Config.block_connection
+          raise Typhoeus::Errors::NoStub.new(self)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/requests/callbacks.rb

@@ -0,0 +1,82 @@
+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.execute_callbacks
+    #   #=> 1
+    #   #=> 2
+    #
+    # You can clear the callbacks:
+    #
+    #   request.on_complete { p 1 }
+    #   request.on_complete { p 2 }
+    #   request.on_complete.clear
+    #   request.execute_callbacks
+    #   #=> []
+    module Callbacks
+
+      module Types
+        # 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
+
+        # Set on_success callback.
+        #
+        # @example Set on_success.
+        #   request.on_success { p "yay" }
+        #
+        # @param [ Block ] block The block to execute.
+        def on_success(&block)
+          @on_success ||= []
+          @on_success << block if block_given?
+          @on_success
+        end
+
+        # Set on_failure callback.
+        #
+        # @example Set on_failure.
+        #   request.on_failure { p "yay" }
+        #
+        # @param [ Block ] block The block to execute.
+        def on_failure(&block)
+          @on_failure ||= []
+          @on_failure << block if block_given?
+          @on_failure
+        end
+      end
+
+      # Execute nessecary callback and yields response. This
+      # include in every case on_complete, on_success if
+      # successful and on_failure if not.
+      #
+      # @example Execute callbacks.
+      #   request.execute_callbacks
+      def execute_callbacks
+        callbacks = Typhoeus.on_complete + on_complete
+
+        if response && response.success?
+          callbacks += Typhoeus.on_success + on_success
+        elsif response
+          callbacks += Typhoeus.on_failure + on_failure
+        end
+
+        callbacks.map{ |callback| callback.call(self.response) }
+      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.configure 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,52 @@
+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)
+        @response.request = self
+        Typhoeus.release_easy(easy)
+        execute_callbacks
+        @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/requests/stubbable.rb

@@ -0,0 +1,29 @@
+module Typhoeus
+  module Requests
+
+    # This module handles stubbing on the request side.
+    # It plays well with the block_connection configuration,
+    # which raises when you make a request which is not stubbed.
+    module Stubbable
+
+      # Override run 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 Run the request.
+      #   request.run
+      #
+      # @return [ Response ] The response.
+      def run
+        if expectation = Expectation.find_by(self)
+          @response = expectation.response
+          @response.mock = true
+          execute_callbacks
+          @response
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/response.rb

@@ -1,123 +1,29 @@
-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/header'
+require 'typhoeus/responses/informations'
+require 'typhoeus/responses/legacy'
+require 'typhoeus/responses/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 Responses::Informations
+    include Responses::Legacy
+    include Responses::Status
+
+    attr_accessor :request, :options, :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
+      @header = options[:header]
     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