First pass of refactoring the actual performing of the request into smaller methods.

lib/httparty.rb

@@ -74,25 +74,24 @@ module HTTParty
       perform_request Net::HTTP::Get, path, options
     end
 
-    # TODO: spec out this    
+    # TODO: spec out this
     def post(path, options={})
       perform_request Net::HTTP::Post, path, options
     end
 
-    # TODO: spec out this    
+    # TODO: spec out this
     def put(path, options={})
       perform_request Net::HTTP::Put, path, options
     end
 
-    # TODO: spec out this    
+    # TODO: spec out this
     def delete(path, options={})
       perform_request Net::HTTP::Delete, path, options
     end
 
     private
-
       def perform_request(http_method, path, options)
-        Request.perform_request(http_method, path, default_options.merge(options))
+        Request.new(http_method, path, default_options.merge(options)).perform
       end
     
       # Makes it so uri is sure to parse stuff like google.com with the http

lib/httparty/request.rb

@@ -2,10 +2,6 @@ module HTTParty
   class Request
     SupportedHTTPMethods = [Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Put, Net::HTTP::Delete]
 
-    def self.perform_request(http_method, path, options={})
-      new(http_method, path, options).perform
-    end
-
     attr_accessor :http_method, :path, :options
     
     def initialize(http_method, path, options={})
@@ -20,58 +16,19 @@ module HTTParty
     def path=(uri)
       @path = URI.parse(uri)
     end
-
-    # FIXME: this method is doing way to much and needs to be split up
-    # options can be any or all of:
-    #   query       => hash of keys/values or a query string (foo=bar&baz=poo)
-    #   body        => hash of keys/values or a query string (foo=bar&baz=poo)
-    #   headers     => hash of headers to send request with
-    #   basic_auth  => :username and :password to use as basic http authentication (overrides basic_auth setting)
-    # Raises exception Net::XXX (http error code) if an http error occured
-    def perform #:nodoc:
-      raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
-      raise ArgumentError, 'only get, post, put and delete methods are supported' unless SupportedHTTPMethods.include?(http_method)
-      raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
-      raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
-      
+    
+    def uri
       uri = path.relative? ? URI.parse("#{options[:base_uri]}#{path}") : path
-      
-      query_string_parts = []
-      query_string_parts << uri.query unless uri.query.blank?
-      
-      if options[:query].is_a?(Hash)
-        query_string_parts << options[:default_params].merge(options[:query]).to_query
-      else
-        query_string_parts << options[:default_params].to_query unless options[:default_params].blank?
-        query_string_parts << options[:query] unless options[:query].blank?
-      end
-      
-      uri.query = query_string_parts.join('&') if query_string_parts.size > 0
-      
-      request        = http_method.new(uri.request_uri)
-      request.body   = options[:body].is_a?(Hash) ? options[:body].to_query : options[:body] unless options[:body].blank?
-      request.initialize_http_header options[:headers]
-      request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password]) if options[:basic_auth]
-      response       = http(uri).request(request)
-      
-      options[:format] ||= format_from_mimetype(response['content-type'])
-      
-      case response
-      when Net::HTTPSuccess
-        parse_response(response.body)
-      when Net::HTTPRedirection
-        options[:limit] -= 1
-        self.path = response['location']
-        perform
-      else
-        response.instance_eval { class << self; attr_accessor :body_parsed; end }
-        begin; response.body_parsed = parse_response(response.body); rescue; end
-        response.error! # raises  exception corresponding to http error Net::XXX
-      end
+      uri.query = query_string(uri)
+      uri
+    end
+    
+    def perform
+      validate!
+      handle_response!(get_response(uri))
     end
 
     private
-
       def http(uri) #:nodoc:
         http = Net::HTTP.new(uri.host, uri.port, options[:http_proxyaddr], options[:http_proxyport])
         http.use_ssl = (uri.port == 443)
@@ -79,6 +36,46 @@ module HTTParty
         http
       end
       
+      def get_response(uri) #:nodoc:
+        request = http_method.new(uri.request_uri)
+        request.body = options[:body].is_a?(Hash) ? options[:body].to_query : options[:body] unless options[:body].blank?
+        request.initialize_http_header options[:headers]
+        request.basic_auth(options[:basic_auth][:username], options[:basic_auth][:password]) if options[:basic_auth]
+        response = http(uri).request(request)
+        options[:format] ||= format_from_mimetype(response['content-type'])
+        response
+      end
+      
+      def query_string(uri) #:nodoc:
+        query_string_parts = []
+        query_string_parts << uri.query unless uri.query.blank?
+
+        if options[:query].is_a?(Hash)
+          query_string_parts << options[:default_params].merge(options[:query]).to_query
+        else
+          query_string_parts << options[:default_params].to_query unless options[:default_params].blank?
+          query_string_parts << options[:query] unless options[:query].blank?
+        end
+        
+        query_string_parts.size > 0 ? query_string_parts.join('&') : nil
+      end
+      
+      # Raises exception Net::XXX (http error code) if an http error occured
+      def handle_response!(response) #:nodoc:
+        case response
+        when Net::HTTPSuccess
+          parse_response(response.body)
+        when Net::HTTPRedirection
+          options[:limit] -= 1
+          self.path = response['location']
+          perform
+        else
+          response.instance_eval { class << self; attr_accessor :body_parsed; end }
+          begin; response.body_parsed = parse_response(response.body); rescue; end
+          response.error! # raises  exception corresponding to http error Net::XXX
+        end
+      end
+      
       def parse_response(body) #:nodoc:
         return nil if body.nil? or body.empty?
         case options[:format]
@@ -96,5 +93,12 @@ module HTTParty
       def format_from_mimetype(mimetype) #:nodoc:
         AllowedFormats.each { |k, v| return k if mimetype.include?(v) }
       end
+      
+      def validate! #:nodoc:
+        raise HTTParty::RedirectionTooDeep, 'HTTP redirects too deep' if options[:limit].to_i <= 0
+        raise ArgumentError, 'only get, post, put and delete methods are supported' unless SupportedHTTPMethods.include?(http_method)
+        raise ArgumentError, ':headers must be a hash' if options[:headers] && !options[:headers].is_a?(Hash)
+        raise ArgumentError, ':basic_auth must be a hash' if options[:basic_auth] && !options[:basic_auth].is_a?(Hash)
+      end
   end
 end