typhoeus 0.5.0.pre → 0.5.0.rc

data/lib/typhoeus/request/actions.rb

@@ -0,0 +1,125 @@
+module Typhoeus
+  class Request
+
+    # 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 (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      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 (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      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 (see Typhoeus::Request#initialize)
+      #
+      # @option options :params [ Hash ] Params hash which
+      #   is attached to the url.
+      # @option options :body [ Hash ] Body hash which
+      #   becomes a PUT request body.
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      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 (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      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 (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      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 (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      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 (see Typhoeus::Request#initialize)
+      #
+      # @option (see Typhoeus::Request#initialize)
+      #
+      # @return (see Typhoeus::Request#initialize)
+      #
+      # @note (see Typhoeus::Request#initialize)
+      def options(url, options = {})
+        Request.run(url, options.merge(:method => :options))
+      end
+    end
+  end
+end

data/lib/typhoeus/request/before.rb

@@ -0,0 +1,30 @@
+module Typhoeus
+  class Request
+
+    # This module provides a way to hook into before
+    # a request runs. This is very powerful
+    # and you should be careful because when you accidently
+    # return a falsy value the request won't be executed.
+    #
+    # @api private
+    module Before
+
+      # Overrride run in order to execute callbacks in
+      # Typhoeus.before. Will break and return when a
+      # callback returns nil or false. Calls super
+      # otherwise.
+      #
+      # @example Run the request.
+      #   request.run
+      def run
+        Typhoeus.before.each do |callback|
+          value = callback.call(self)
+          if value.nil? || value == false || value.is_a?(Response)
+            return value
+          end
+        end
+        super
+      end
+    end
+  end
+end

data/lib/typhoeus/request/block_connection.rb

@@ -0,0 +1,52 @@
+module Typhoeus
+  class Request
+
+    # 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.
+    #
+    # @api private
+    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
+      #
+      # @raise [Typhoeus::Errors::NoStub] If connection is blocked
+      #   and no stub defined.
+      def run
+        if blocked?
+          raise Typhoeus::Errors::NoStub.new(self)
+        else
+          super
+        end
+      end
+
+      # Returns wether a request is blocked or not. Takes
+      # request.block_connection and Typhoeus::Config.block_connection
+      # into consideration.
+      #
+      # @example Blocked?
+      #   request.blocked?
+      #
+      # @return [ Boolean ] True if blocked, false else.
+      def blocked?
+        if block_connection.nil?
+         Typhoeus::Config.block_connection
+        else
+         block_connection
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/request/callbacks.rb

@@ -0,0 +1,98 @@
+module Typhoeus
+  class Request
+
+    # 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 { |response| p 1 }
+    #   request.on_complete { |response| p 2 }
+    #   request.execute_callbacks
+    #   #=> 1
+    #   #=> 2
+    #
+    # You can clear the callbacks:
+    #
+    #   request.on_complete { |response| p 1 }
+    #   request.on_complete { |response| p 2 }
+    #   request.on_complete.clear
+    #   request.execute_callbacks
+    #   #=> []
+    module Callbacks
+
+      module Types # :nodoc:
+        # Set on_complete callback.
+        #
+        # @example Set on_complete.
+        #   request.on_complete { |response| p "yay" }
+        #
+        # @param [ Block ] block The block to execute.
+        #
+        # @yield [ Typhoeus::Response ]
+        #
+        # @return [ Array<Block> ] All on_complete blocks.
+        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 { |response| p "yay" }
+        #
+        # @param [ Block ] block The block to execute.
+        #
+        # @yield [ Typhoeus::Response ]
+        #
+        # @return [ Array<Block> ] All on_success blocks.
+        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 { |response| p "yay" }
+        #
+        # @param [ Block ] block The block to execute.
+        #
+        # @yield [ Typhoeus::Response ]
+        #
+        # @return [ Array<Block> ] All on_failure blocks.
+        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
+      #
+      # @return [ void ]
+      #
+      # @api private
+      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 → request}/marshal.rb

@@ -1,5 +1,5 @@
 module Typhoeus
-  module Requests
+  class Request
 
     # This module contains custom serializer.
     module Marshal

data/lib/typhoeus/{requests → request}/memoizable.rb

@@ -1,12 +1,14 @@
 module Typhoeus
-  module Requests
+  class Request
 
     # This module handles the GET request memoization
     # on the request side. Memoization needs to be turned
     # on:
-    #   Typhoeus.configre do |config|
+    #   Typhoeus.configure do |config|
     #     config.memoize = true
     #   end
+    #
+    # @api private
     module Memoizable
 
       # Override response setter and memoizes response

data/lib/typhoeus/{requests → request}/operations.rb

@@ -1,5 +1,5 @@
 module Typhoeus
-  module Requests
+  class Request
 
     # This module contains everything what is necessary
     # to make a single request.
@@ -21,6 +21,8 @@ module Typhoeus
         # @param [ Hash ] options The options hash.
         #
         # @return [ Response ] The response.
+        #
+        # @deprecated
         def run(url, options = {})
           new(url, options).run
         end
@@ -29,7 +31,7 @@ module Typhoeus
       # Run a request.
       #
       # @example Run a request.
-      #  request.run
+      #  Typhoeus::Request.new("www.example.com").run
       #
       # @return [ Response ] The response.
       def run
@@ -41,10 +43,28 @@ module Typhoeus
         )
         easy.prepare
         easy.perform
-        @response = Response.new(easy.to_hash)
+        finish(Response.new(easy.to_hash))
         Typhoeus.release_easy(easy)
-        complete
-        @response
+        response
+      end
+
+      # Sets a response, the request on the response
+      # and executes the callbacks.
+      #
+      # @param [Typhoeus::Response] response The response.
+      # @param [Boolean] bypass_memoization Wether to bypass
+      #   memoization or not. Decides how the response is set.
+      #
+      # @return [Typhoeus::Response] The response.
+      def finish(response, bypass_memoization = nil)
+        if bypass_memoization
+          @response = response
+        else
+          self.response = response
+        end
+        self.response.request = self
+        execute_callbacks
+        response
       end
     end
   end

data/lib/typhoeus/{requests → request}/responseable.rb

@@ -1,5 +1,5 @@
 module Typhoeus
-  module Requests
+  class Request
 
     # This module contains logic for having a reponse
     # getter and setter.

data/lib/typhoeus/request/stubbable.rb

@@ -0,0 +1,28 @@
+module Typhoeus
+  class Request
+
+    # 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.
+    #
+    # @api private
+    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)
+          finish(expectation.response)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/typhoeus/response.rb

@@ -1,17 +1,33 @@
-require 'typhoeus/responses/legacy'
-require 'typhoeus/responses/informations'
-require 'typhoeus/responses/status'
-require 'typhoeus/responses/header'
+require 'typhoeus/response/header'
+require 'typhoeus/response/informations'
+require 'typhoeus/response/status'
 
 module Typhoeus
 
   # This class respresents the response.
   class Response
-    include Responses::Status
-    include Responses::Informations
-    include Responses::Legacy
+    include Response::Informations
+    include Response::Status
 
-    attr_accessor :request, :options
+    # 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.
     #
@@ -23,6 +39,12 @@ module Typhoeus
     # @return [ Response ] The new response.
     def initialize(options = {})
       @options = options
+      @headers = options[:headers]
+    end
+
+    # @api private
+    def mock
+      defined?(@mock) ? @mock : options[:mock]
     end
   end
 end