lib/weary/resource.rb in weary-1.0.1 vs lib/weary/resource.rb in weary-1.1.0

@@ -5,10 +5,12 @@
   # A description of a resource made available by an HTTP request. That
   # description is composed primarily of a url template, the HTTP method to
   # retrieve the resource and some constraints on the parameters necessary
   # to complete the request.
   class Resource
+    include Weary::Requestable
+
     UnmetRequirementsError = Class.new(StandardError)
 
     attr_reader :method
 
     def initialize(method, uri)
@@ -47,28 +49,10 @@
     def defaults(hash=nil)
       @defaults = hash unless hash.nil?
       @defaults ||= {}
     end
 
-    # An accessor to set HTTP request headers.
-    def headers(hash=nil)
-      @headers = hash unless hash.nil?
-      @headers ||= {}
-    end
-
-    # Set up a Rack::Middleware to be used by the Request (which is
-    # Rack-friendly).
-    def use(middleware, *args, &block)
-      @middlewares ||= []
-      @middlewares << [middleware, args.compact, block]
-    end
-
-    # Convenience method to set a User Agent Header
-    def user_agent(agent)
-      headers.update 'User-Agent' => agent
-    end
-
     # Tell the Resource to anticipate Basic Authentication. Optionally,
     # tell the Resource what parameters to use as credentials.
     #
     # user - The parameter in which to expect the username (defaults to :username)
     # pass - The parameter in which to expect the password (defaults to :password)
@@ -94,11 +78,11 @@
       !!@authenticates
     end
 
     # The keys expected as parameters to the Request.
     def expected_params
-      defaults.keys.map(&:to_s) | optional.map(&:to_s) | required.map(&:to_s)
+      (defaults.keys | optional | required).map(&:to_s).uniq
     end
 
     # Does the Resource expect this parameter to be used to make the Request?
     def expects?(param)
       expected_params.include? param.to_s
@@ -120,32 +104,51 @@
     #
     # Returns the Request.
     # Raises a Weary::Resource::UnmetRequirementsError if the requirements
     #   are not met.
     def request(params={})
-      params.delete_if {|k,v| v.nil? || v.to_s.empty? }
-      params.update(defaults)
+      normalize_parameters params
       raise UnmetRequirementsError, "Required parameters: #{requirements}" \
         unless meets_requirements? params
-      credentials = pull_credentials params if authenticates?
-      mapping = url.keys.map {|k| [k, params.delete(k) || params.delete(k.to_sym)] }
-      request = Weary::Request.new url.expand(Hash[mapping]), @method do |r|
-        r.headers headers
-        if !@middlewares.nil? && !@middlewares.empty?
-          @middlewares.each {|middleware| r.use *middleware }
-        end
+      credentials = pull_credentials params
+      pairs = pull_url_pairs params
+      request = construct_request expand_url(pairs), params, credentials
+      yield request if block_given?
+      request
+    end
+    alias build request
+
+    private
+
+    # Private: Build the Request object with the given Resource parameters.
+    def construct_request(uri, params, credentials=[])
+      Weary::Request.new uri, @method do |r|
+        pass_values_onto_requestable(r)
         if !expected_params.empty?
           r.params params.reject {|k,v| !expects? k }
         end
         r.send @authenticates, *credentials if authenticates?
       end
-      yield request if block_given?
-      request
     end
-    alias build request
 
+    # Private: For a set of parameters passed in to build a Request, delete
+    # those with no values, and merge them with the defaults.
+    def normalize_parameters(params)
+      params.delete_if {|k,v| v.nil? || v.to_s.empty? }
+      params.update(defaults)
+      params
+    end
 
-    private
+    # Private: Expand the url template with the passed pairs to get the
+    # final url.
+    def expand_url(pairs)
+      url.expand Hash[pairs]
+    end
+
+    # Private: Separate the parameters needed to construct a url.
+    def pull_url_pairs(params)
+      url.keys.map {|k| [k, params.delete(k) || params.delete(k.to_sym)] }
+    end
 
     # Private: Separate the credentials for authentication from the other
     # request parameters.
     def pull_credentials(params)
       (@credentials || []).map do |credential|