restfully 0.3.2 → 0.4.0

data/lib/restfully/extensions.rb

@@ -4,23 +4,6 @@ end unless defined?(BasicObject)
 
 # monkey patching:
 class Hash
-  # Taken from ActiveSupport
-  def symbolize_keys
-    inject({}) do |options, (key, value)|
-      options[(key.to_sym rescue key) || key] = value
-      options
-    end
-  end
-
-  # Taken from ActiveSupport  
-  def stringify_keys
-    inject({}) do |options, (key, value)|
-      options[key.to_s] = value
-      options
-    end
-  end
-
-
   # This is by no means the standard way to transform ruby objects into query parameters
   # but it is targeted at our own needs
   def to_params

data/lib/restfully/http/adapters/abstract_adapter.rb

@@ -21,7 +21,7 @@ module Restfully
           raise NotImplementedError, "PUT is not supported by your adapter."
         end
         def delete(request)
-          raise NotImplementedError, "DELETEis not supported by your adapter."
+          raise NotImplementedError, "DELETE is not supported by your adapter."
         end
       end
       

data/lib/restfully/http/adapters/rest_client_adapter.rb

@@ -5,14 +5,35 @@ module Restfully
   module HTTP
     module Adapters
       class RestClientAdapter < AbstractAdapter
+        
         def initialize(base_uri, options = {})
           super(base_uri, options)
           @options[:user] = @options.delete(:username)
-        end
+        end # def initialize
+        
+        def head(request)
+          in_order_to_get_the_response_to(request) do |resource|
+            resource.head(request.headers)
+          end
+        end # def get
+        
         def get(request)
+          in_order_to_get_the_response_to(request) do |resource|
+            resource.get(request.headers)
+          end
+        end # def get
+        
+        def post(request)
+          in_order_to_get_the_response_to(request) do |resource|
+            resource.post(request.raw_body, request.headers)
+          end
+        end # def post
+        
+        protected
+        def in_order_to_get_the_response_to(request, &block)
           begin
             resource = RestClient::Resource.new(request.uri.to_s, @options)
-            response = resource.get(request.headers)
+            response = block.call(resource)
             headers = response.headers
             body = response.to_s
             headers.delete(:status)
@@ -23,7 +44,8 @@ module Restfully
             status = e.http_code
           end
           Response.new(status, headers, body)
-        end
+        end # def in_order_to_get_the_response_to
+        
       end
     
     end

data/lib/restfully/http/request.rb

@@ -2,8 +2,8 @@ require 'uri'
 module Restfully
   module HTTP
     class Request
-      include Headers
-      attr_reader :headers, :body, :uri
+      include Headers, Restfully::Parsing
+      attr_reader :headers, :uri
       attr_accessor :retries
       def initialize(url, options = {})
         options = options.symbolize_keys
@@ -12,10 +12,27 @@ module Restfully
         if query = options.delete(:query)
           @uri.query = [@uri.query, query.to_params].compact.join("&")
         end
-        @body = body
+        @body = options.delete(:body)
         @retries = 0
       end
       
+      
+      def body
+        if @body.kind_of?(String)
+          @unserialized_body ||= unserialize(@body, :content_type => @headers['Content-Type'])
+        else
+          @body
+        end
+      end
+      
+      def raw_body
+        if @body.kind_of?(String)
+          @body
+        else
+          @serialized_body ||= serialize(@body, :content_type => @headers['Content-Type'])
+        end
+      end
+      
       def add_headers(headers = {})
         @headers.merge!(sanitize_http_headers(headers || {}))
       end

data/lib/restfully/http/response.rb

@@ -1,19 +1,37 @@
 module Restfully
   module HTTP
     # Container for an HTTP Response. Has <tt>status</tt>, <tt>headers</tt> and <tt>body</tt> properties.
-    # The body is automatically parsed into a ruby object based on the response's <tt>Content-Type</tt> header.
     class Response
       include Headers, Restfully::Parsing
       attr_reader :status, :headers
+      
+      # <tt>body</tt>:: may be a string (that will be parsed when calling the #body function), or an object (that will be returned as is when calling the #body function)
       def initialize(status, headers, body)
         @status = status.to_i
         @headers = sanitize_http_headers(headers)
-        @body = (body.nil? || body.empty?) ? nil : body.to_s
+        @body = body
       end
       
       def body
-        @unserialized_body ||= unserialize(@body, :content_type => @headers['Content-Type']) unless @body.nil?
+        if @body.kind_of?(String)
+          if @body.empty?
+            nil
+          else
+            @unserialized_body ||= unserialize(@body, :content_type => @headers['Content-Type'])
+          end
+        else
+          @body
+        end
+      end
+      
+      def raw_body
+        if @body.kind_of?(String)
+          @body
+        else
+          @serialized_body ||= serialize(@body, :content_type => @headers['Content-Type']) unless @body.nil?
+        end
       end
+      
     end
   end
 end

data/lib/restfully/link.rb

@@ -1,3 +1,4 @@
+require 'uri'
 module Restfully
   class Link
     
@@ -9,7 +10,7 @@ module Restfully
     def initialize(attributes = {})
       @rel = attributes['rel']
       @title = attributes['title']
-      @href = attributes['href']
+      @href = URI.parse(attributes['href'].to_s)
       @resolvable = attributes['resolvable'] || false
       @resolved = attributes['resolved'] || false
     end
@@ -20,8 +21,8 @@ module Restfully
     
     def valid?
       @errors = []
-      if href.nil? || href.empty?
-        errors << "href cannot be empty."
+      if href.nil?
+        errors << "href cannot be nil."
       end
       unless VALID_RELATIONSHIPS.include?(rel)
         errors << "#{rel} is not a valid link relationship."

data/lib/restfully/resource.rb

@@ -1,111 +1,180 @@
-require 'delegate'
-
 module Restfully
   
-  # Suppose that the load method has been called on the resource before trying to access its attributes or associations
-  
-  class Resource < DelegateClass(Hash)
+  # This class represents a Resource, which can be accessed and manipulated
+  # via HTTP methods.
+  # 
+  # The <tt>#load</tt> method must have been called on the resource before
+  # trying to access its attributes or links.
+  # 
+  class Resource
     
-    undef :type if self.respond_to? :type
-    attr_reader :uri, :session, :state, :raw, :associations
-
+    attr_reader :uri, 
+                :session, 
+                :links, 
+                :title, 
+                :properties, 
+                :executed_requests
+    
+    # == Description
+    # Creates a new Resource.
+    # <tt>uri</tt>:: a URI object representing the URI of the resource
+    #                (complete, absolute or relative URI)
+    # <tt>session</tt>:: an instantiated Restfully::Session object
+    # <tt>options</tt>:: a hash of options (see below)
+    # == Options
+    # <tt>:title</tt>:: an optional title for the resource
     def initialize(uri, session, options = {})
       options = options.symbolize_keys
-      @uri = uri
+      @uri = uri.kind_of?(URI) ? uri : URI.parse(uri.to_s)
       @session = session
-      @state = :unloaded
-      @attributes = {}
-      super(@attributes)
-      @associations = {}
+      @title = options[:title]
+      reset
     end
     
-    def loaded?;    @state == :loaded;    end
+    # Resets all the inner objects of the resource
+    # (you must call <tt>#load</tt> if you want to repopulate the resource).
+    def reset
+      @executed_requests = Hash.new
+      @links = Hash.new
+      @properties = Hash.new
+      self
+    end
+    
+    # == Description
+    # Returns the value corresponding to the specified key, 
+    # among the list of resource properties
+    # 
+    # == Usage
+    #   resource["uid"]
+    #   => "rennes"
+    def [](key)
+      @properties[key]
+    end
     
     def method_missing(method, *args)
-      if association = @associations[method.to_s]
-        session.logger.debug "Loading association #{method}, args=#{args.inspect}"
-        association.load(*args)
+      if link = @links[method.to_s]
+        session.logger.debug "Loading link #{method}, args=#{args.inspect}"
+        link.load(*args)
       else
         super(method, *args)
       end
     end
-  
+    
+    # == Description
+    # Executes a GET request on the resource, and populate the list of its
+    # properties and links
+    # <tt>options</tt>:: list of options to pass to the request (see below)
+    # == Options
+    # <tt>:reload</tt>:: if set to true, a GET request will be triggered even if the resource has already been loaded [default=false]
+    # <tt>:query</tt>:: a hash of query parameters to pass along the request. E.g. : resource.load(:query => {:from => (Time.now-3600).to_i, :to => Time.now.to_i})
+    # <tt>:headers</tt>:: a hash of HTTP headers to pass along the request. E.g. : resource.load(:headers => {'Accept' => 'application/json'})
+    # <tt>:body</tt>:: if you already have the unserialized response body of this resource, you may pass it so that the GET request is not triggered.
     def load(options = {})
       options = options.symbolize_keys
-      force_reload = !!options.delete(:reload) || options.has_key?(:query)
-      if loaded? && !force_reload && options[:raw].nil?
+      force_reload = !!options.delete(:reload)
+      if !force_reload && (request = executed_requests['GET']) && request['options'] == options && request['body']
         self
       else  
-        @associations.clear
-        @attributes.clear
-        @raw = options[:raw]
-        if raw.nil? || force_reload
-          response = session.get(uri, options) 
-          @raw = response.body
-        end
-        (raw['links'] || []).each{|link| define_link(Link.new(link))}
-        raw.each do |key, value|
-          case key
-          # when "uid", "type"
-            # instance_variable_set "@#{key}".to_sym, value
-          when 'links'  then  next
-          else
-            case value
-            when Hash
-              @attributes.store(key, SpecialHash.new.replace(value)) unless @associations.has_key?(key)
-            when Array
-              @attributes.store(key, SpecialArray.new(value))
-            else
-              @attributes.store(key, value)
-            end
-          end
+        reset
+        executed_requests['GET'] = {
+          'options' => options, 
+          'body' => options[:body] || session.get(uri, options).body
+        }
+        executed_requests['GET']['body'].each do |key, value|
+          populate_object(key, value)
         end
-        @state = :loaded
         self
       end
     end
+  
+    def submit(payload, options = {})
+      options = options.symbolize_keys
+      raise NotImplementedError, "The POST method is not allowed for this resource." unless http_methods.include?('POST')
+      raise ArgumentError, "You must pass a payload string" unless payload.kind_of?(String)
+      session.post(payload, options)
+    end
+    
+    # == Description
+    # Returns the list of allowed HTTP methods on the resource.
+    # == Usage
+    #   resource.http_methods    
+    #   => ['GET', 'POST']
+    # 
+    def http_methods
+      if executed_requests['HEAD'].nil?
+        response = session.head(uri)
+        executed_requests['HEAD'] = {'headers' => response.headers}
+      end
+      (executed_requests['HEAD']['headers']['Allow'] || "GET").split(/,\s*/)
+    end
     
     def respond_to?(method, *args)
-      @associations.has_key?(method.to_s) || super(method, *args)
+      @links.has_key?(method.to_s) || super(method, *args)
     end
     
-    # Removed: use `y resource` to get pretty output
-    # def inspect(options = {:space => "\t"})
-    #   output = "#<#{self.class}:0x#{self.object_id.to_s(16)}"
-    #   if loaded?
-    #     output += "\n#{options[:space]}------------ META ------------"
-    #     output += "\n#{options[:space]}@uri: #{uri.inspect}"
-    #     output += "\n#{options[:space]}@uid: #{uid.inspect}"
-    #     output += "\n#{options[:space]}@type: #{type.inspect}"
-    #     @associations.each do |title, assoc|
-    #       output += "\n#{options[:space]}@#{title}: #{assoc.class.name}"
-    #     end
-    #     unless @attributes.empty?
-    #       output += "\n#{options[:space]}------------ PROPERTIES ------------"
-    #       @attributes.each do |key, value|
-    #         output += "\n#{options[:space]}#{key.inspect} => #{value.inspect}"
-    #       end
-    #     end
-    #   end
-    #   output += ">"
-    # end    
+    def inspect(*args)
+      @properties.inspect(*args)
+    end
+    
+    def pretty_print(pp)
+      pp.text "#<#{self.class}:0x#{self.object_id.to_s(16)}"
+      pp.nest 2 do
+        pp.breakable
+        pp.text "@uri="
+        uri.pretty_print(pp)
+        if @links.length > 0
+          pp.breakable
+          pp.text "LINKS"
+          pp.nest 2 do
+            @links.to_a.each_with_index do |(key, value), i|
+              pp.breakable
+              pp.text "@#{key}=#<#{value.class}:0x#{value.object_id.to_s(16)}>"
+              pp.text "," if i < @links.length-1
+            end
+          end  
+        end
+        if @properties.length > 0
+          pp.breakable
+          pp.text "PROPERTIES"
+          pp.nest 2 do
+            @properties.to_a.each_with_index do |(key, value), i|
+              pp.breakable
+              pp.text "#{key.inspect}=>"
+              value.pretty_print(pp)
+              pp.text "," if i < @properties.length-1
+            end
+          end
+        end
+        yield pp if block_given?
+      end
+      pp.text ">"
+    end   
     
     protected
+    def populate_object(key, value)
+      case key
+      when "links"
+        value.each{|link| define_link(Link.new(link))}
+      else
+        case value
+        when Hash
+          @properties.store(key, SpecialHash.new.replace(value)) unless @links.has_key?(key)
+        when Array
+          @properties.store(key, SpecialArray.new(value))
+        else
+          @properties.store(key, value)
+        end
+      end
+    end
     def define_link(link)
       if link.valid?
         case link.rel
         when 'parent'
-          @associations['parent'] = Resource.new(link.href, session)
+          @links['parent'] = Resource.new(uri.merge(link.href), session)
         when 'collection'
-          raw_included = link.resolved? ? raw[link.title] : nil
-          @associations[link.title] = Collection.new(link.href, session, 
-            :raw => raw_included,
-            :title => link.title)
+          @links[link.title] = Collection.new(uri.merge(link.href), session, :title => link.title)
         when 'member'
-          raw_included = link.resolved? ? raw[link.title] : nil
-          @associations[link.title] = Resource.new(link.href, session, 
-            :title => link.title,
-            :raw => raw_included)
+          @links[link.title] = Resource.new(uri.merge(link.href), session, :title => link.title)
         when 'self'
           # we do nothing
         end
@@ -113,6 +182,7 @@ module Restfully
         session.logger.warn link.errors.join("\n")
       end
     end
+
     
   end # class Resource
 end # module Restfully