rubyrest 0.0.5 → 0.1.0

data/lib/rubyrest/atom.rb

@@ -5,245 +5,269 @@
 #
 # $Id:$
 module RubyRest
-  
   module Atom
-    include RubyRest::Tools
-      
-      NAMESPACES = { 
+    
+    NAMESPACES = { 
         "xmlns" => "http://www.w3.org/2005/Atom", 
-        "xmlns:moodisland" => "http://www.moodisland.com/ns#" 
-      }
-  
-      ATOM_TYPE = "application/atom+xml".freeze
-      ATOMSERV_TYPE = "application/atomserv+xml".freeze
-      HTML_TYPE = "text/html".freeze
-      WORKSPACE_METHOD = "dashboard".freeze
-      MODULEID = "Ruby-on-Rest (http://rubyrest.rubyforge.org)".freeze
-      
-      
-    
-      
-      #
-      # Formats the response as a Atom feed, Atom Entry or 
-      # Atom Service Document
-      def format_response( request, response )
-    
-        builder = Builder::XmlMarkup.new( :target => response.body )
-        builder.instruct!
-    
-        if @service_method == "dashboard"
-          response[ "content-type" ] = ATOMSERV_TYPE
-          build_service_document( @result, builder, request.request_uri  )
-        else 
-          response[ "content-type" ] = ATOM_TYPE 
-          if @result.respond_to? "each"
-            title = @property || @model
-            build_feed( @result, builder, request.request_uri, request.path, title )
-          else build_entry( @result, builder, request.path ) end
-        end
-      end
-  
-  
-      # Builds an Atom Service Document. This is a representation of the 
-      # user's dashboard or initial workspace.
-      def build_service_document( collections, builder, uri )
-        builder.service( NAMESPACES ){
-          builder.workspace {
-            builder.title "Dashboard"
-            if collections != nil and collections.respond_to?( :each ) 
-                collections.each { |col| 
-                  builder.collection( { "href" =>  "/#{col}" } ) {
-                    builder.title col
-                    builder.accept "entry"
-                  }
-                }
-            end
-          }
-        }
-      end
-  
-      # Builds an Atom Feed representation of the specified collection
-      # of entries
-      #
-      def build_feed( entries, builder, uri, path, title )
-        builder.feed( NAMESPACES ) {
-          builder.id uri
-          builder.link( { "rel" => "self", "href" => path, "type" => ATOM_TYPE } )
-          builder.link( { "rel" => "alternate", "href" => uri, "type" => HTML_TYPE } )
-          builder.title title
-          builder.updated format_atom_date( Time.now )
-          entries.each { |object| build_entry( object, builder, uri ) }
-        }
-      end
-  
-      # Builds an Atom Entry representation of the specified
-      # object.
-      #
-      # The object is supposed to implement the following mandatory methods: 
-      # atom_id, atom_title, atom_author, atom_updated, atom_summary
-      #
-      # The object can implement the following optionnal methods:
-      # atom_related, atom_content
-      #
-      def build_entry( object, builder, uri )
-      
-        entry_link = uri 
-        entry_link = "#{uri}/#{object.atom_id}" if @id == nil
-        
-        builder.entry( NAMESPACES ) {
-          builder.title object.atom_title
-          builder.author { builder.name object.atom_author }
-          builder.updated format_atom_date( object.atom_updated )
-          builder.id entry_link
-          builder.summary object.atom_summary
-          builder.link( :rel => :alternate, :href => entry_link )
-
-          if object.respond_to?( :atom_related )
-            related_entities = object.atom_related( @principal )
-            if related_entities != nil 
-              related_entities.each{ |related| 
-                case related[:type]
-                  when :child
-                    builder.link( :rel => related[:type], :href => "#{entry_link}/#{related[:model]}", :title => related[:model], :type =>  ATOM_TYPE ) 
-                  when :parent
-                    builder.link( :rel => related[:type], :href => "/#{related[:model]}/#{object.send related[:model]}", :title => related[:model], :type =>  ATOM_TYPE ) 
-                  else :siblings
-                    builder.link( :rel => related[:type], :href => "/#{related[:model]}", :title => related[:model], :type =>  ATOM_TYPE ) 
-                end
-             }
-            end 
-          end
-      
-          builder.moodisland :content do
-            object.atom_content( builder ) if object.respond_to? :atom_content
-          end
-        }
+        "xmlns:rubyrest" => "http://rubyrest.rubyforge.org/ns#" 
+    }
+    
+    ATOM_DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
     
+    
+    
+    # Ruby-on-Rest specialization of the REXML document
+    # class. Adds some convenient ways of accessing data from 
+    # a Atom document
+    class Document < REXML::Document
+      
+      def method_missing( name, *args )
+        get_value( name )
       end
       
-      # This module provides some default, arbitrary implementations
-      # for methods required by RubyRest in order to 
-      # provide an Atom Entry representation out of a domain object.
-      # 
-      # Developpers can choose whether to use this implementation
-      # or to provide their own.
-      module Entry
-        
-        # Returns the Atom Entry title
-        def atom_title
-          self.name
-        end
-
-        # Returns the Atom Entry Summary. Synonym of atom_title
-        def atom_summary
-          atom_title
-        end
+      # Resolves the missing method into a content property
+      # and returns its text value
+      def get_value( name, required=true )
+        location = "/entry/rubyrest:content/#{name}"
+        value = text( location )
+        raise "missing value at location #{location} in #{self.to_s}" if required && !value
+        return value
+      end
+      
+      def set_value( name, value )
+        get_text( "/entry/rubyrest:content/#{name}" ).value = value
+      end
 
-        # Returns the generated token
-        def atom_id
-          self.id
-        end
+      # Shortcut for the id element contained
+      # within the content.
+      def id
+        text( "/entry/rubyrest:content/id" )
+      end
 
-        # Returns Time.now
-        def atom_updated
-          self.updated
-        end
+      # Overrides the default implementation
+      # by returning a new Ruby-on-Rest Atom Document
+      def clone
+        self.class.new self.to_s
+      end
 
-        # Not a very relevant buy necessary information
-        def atom_author
-          self.createdby
-        end
+    end
+    
+    # Main Atom formatter class, composed of more specialized objects
+    # such as Feed, Entry, ServiceDocument and property formatters
+    class Formatter
+      
+      attr_reader :app
+      
+      # Inits all the specific formatters and property handlers used by this
+      # main formatter
+      def initialize( app )
+        @app = app
         
-        # Adds some convenience methods to a standard REXML
-        # document. This class supposes that the document is an Atom
-        # entry
-        class Document < REXML::Document 
-
-          # Resolves the missing method into a content property
-          # and returns its text value
-          def method_missing( name, *args )
-            location = "/entry/moodisland:content/#{name}"
-            method_name = name.to_s.chomp
-            if method_name == name.to_s
-              text( location )
-            else get_text( location ).value = args[0] end
-          end
-          
-          # Shortcut for the id element contained
-          # within the content.
-          def id
-            text( "/entry/moodisland:content/id" )
-          end
-          
-          # Overrides the default implementation
-          # by returning a new Ruby-on-Rest Atom Document
-          def clone
-            self.class.new self.to_s
-          end
-          
-        end
-
+        @formatters=Hash.new
+        @formatters[:feed]=FeedFormatter.new( self )
+        @formatters[:entry]=EntryFormatter.new( self )
+        @formatters[:service_doc]=ServiceDocFormatter.new( self )
+        
+        @props=Hash.new
+        @props[:simple]=SimpleProperty.new( self )
+        @props[:date]=DateProperty.new( self )
       end
       
+      # Resolves the specified name into a formatter
+      # object
+      def formatter_for_name( name )
+        raise "No formatter was found for name #{name}" if !@formatters[name]
+        return @formatters[name]
+      end
       
-      # This module provides a failsafe implementation for
-      # methods required by RubyRest in order to 
-      # provide an Atom Entry representation out of a domain object.
-      # 
-      # Developpers should rather use RubyRest::Atom::Entry or 
-      # provide their own.
-      module DummyEntry
-        
-        # Returns the object's class name
-        def atom_title
-          self.class.name
-        end
-
-        # Returns the Atom Entry Summary. 
-        # Synonym of atom_title
-        def atom_summary
-          atom_title
-        end
-
-        # Generates an id from the current time value
-        def atom_id
-          Time.now.to_i
-        end
-
-        # Returns Time.now
-        def atom_updated
-          Time.now
-        end
-
-        # Overrides the implementation provided
-        # by RubyRest::Atom::Entry
-        def atom_author
-          MODULEID
-        end
-
+      # Resolves the formatter to use
+      def formatter_for_model( object )
+        return @formatters[:feed] if @app.is_a_collection( object )
+        return @formatters[:service_doc] if @app.is_a_service_doc( object )
+        @formatters[:entry]
+      end
+      
+      # Performs actual formatting
+      def format( model, params )
+        formatter_for_model( model ).format( model, params )
+      end
+      
+      # Resolves the specified options into the appropiate
+      # property handler
+      def property( options )
+        @props[options[:type]]||@props[:simple]
+      end
+      
+    end
+    
+    class SimpleProperty
+      
+      def initialize( parent )
+        @parent = parent
+      end
+      
+      def tag( options )
+        value = options[:tag]||options[:property]
+        return value.to_s
+      end
+      
+      def object_value( object, options )
+        object.send options[:property]
+      end
+      
+      def xml_value( object, options )
+        return object.get_value( tag( options ), options[:required]||true )
+      end
+      
+      def bind( object, options, value  )
+        object.send options[:property].to_s + "=", value
+      end
+      
+      def parse( object, options, xml )
+        return if options[:bind] == :response
+        bind( object, options, value_from_xml( options, xml ) )
       end
       
-      # Very simple module that adds some binding facilities
-      #
-      module EntryBinder 
+      def value_from_xml( options, xml )
+        xml_value( xml, options )
+      end
+      
+      def value_from_model( options, object )
+        object_value( object, options ).to_s
+      end
+      
+      def format( object, options, xml )
+        return if options[:bind] == :request
+        value  = value_from_model( options, object )
+        new_element = xml.add_element( tag( options ) )
+        new_element.add_text( value.to_s ) if value != nil 
+      end
+      
+    end
+    
+    class DateProperty < SimpleProperty
+      
+      def date2string( date )
+        date = Time.now if !date
+        date.strftime( ATOM_DATE_FORMAT )
+      end
+      
+      def string2date( date )
+        Date.strptime( value, ATOM_DATE_FORMAT )
+      end
+      
+      def value_from_model( options, object )
+        date2string( object_value( object, options ) )
+      end
+      
+      def value_from_xml( options, xml )
+        string2date( xml_value( xml, options ) )
+      end
+      
+    end
+    
+    class DomainFormatter
+      def initialize( parent )
+        @parent = parent
+      end
+    end
+    
+    class FeedFormatter < DomainFormatter
+      
+      def format( objects, params )
+        params[:content_type]="application/atom+xml"
+        xml = REXML::Document.new
+        xml << REXML::XMLDecl.default
+        feed = xml.add_element( "feed", NAMESPACES )
+        feed.add_element( "id" ).add_text( params[:path] )
+        feed.add_element( "title" ).add_text( params[:path] )
+        objects.each{ |o| @parent.formatter_for_name(:entry).format_entry( o, feed, params ) } if objects 
+        return xml
+      end
+    
+    end
+    
+    class EntryFormatter < DomainFormatter
+      
+      def format( object, params )
+        params[:content_type]="application/atom+xml"
+        xml = REXML::Document.new
+        xml << REXML::XMLDecl.default
+        format_entry( object, xml, params )
+        return xml
+      end
+      
+      def format_entry( object, xml, params )
+        resource = @parent.app.resource_for_model( object )
+        raise "no resource found for entry #{object}" if !resource
         
-        # Binds a property against the matching
-        # child element in the specified atom entry xml source. 
-        # The base node to look into is /entry/content
-        def atom_bind( xml, property, mandatory = true )
-          location = "/entry/content/#{property}"
-          node = REXML::XPath.first( xml, location )
-          if node == nil
-            raise "no node found for location #{location}" if mandatory == true 
-            return
-          end
-          if self.respond_to?( "#{property}=" )
-            self.method( "#{property}=").call( node.text ) 
-          else self[ property.intern ] = node.text end 
-
-        end
-
+        entry = xml.add_element( "entry", NAMESPACES )
+        entry.add_element( "title" )
+        entry.add_element( "author" )
+        entry.add_element( "updated" )
+        entry.add_element( "id" )
+        entry.add_element( "summary" )
+        
+        resource.links.each{ |link|
+          entry.add_element( "link", link )
+        }
+        
+        content = entry.add_element( "rubyrest:content" )
+        resource.props.each{ |map| 
+          @parent.property( map ).format( object, map, content ) 
+        }
       end
+    end
+    
+    
+    class ServiceDocFormatter < DomainFormatter
+      
+      def format( service_doc, params )
+        params[:content_type]="application/atomserv+xml"
+        xml = REXML::Document.new
+        xml << REXML::XMLDecl.default
+        service = xml.add_element( "service", NAMESPACES )
+        workspace = service.add_element( "workspace" )
+        workspace.add_element( "atom:title" )
+        service_doc.collections.each{ |col| 
+          collection = workspace.add_element( "collection", { "href" => col.uri } )
+          collection.add_element( "atom:title" ).add_text( col.title )
+          collection.add_element( "accept" ).add_text( col.accept ) if col.accept
+        }
+        return xml
+      end
+      
+    end
+    
+    # Superclass provided by the framework, so that
+    # it's easy to identify resources to be formatted as 
+    # service document entries
+    class ServiceDocument
+      
+      attr_reader :collections
+      
+      def initialize
+        @collections = []
+      end
+      
+      def add( uri, title, accept )
+        @collections << ServiceCollection.new( uri, title, accept )
+      end
+      
+    end
+    
+    class ServiceCollection
+      
+      attr_accessor :uri, :title, :accept
+      
+      def initialize( uri, title, accept = nil )
+        @uri = uri
+        @title = title
+        @accept = accept
+      end
+      
+    end
+    
     
   end
 end

data/lib/rubyrest/client.rb

@@ -10,31 +10,25 @@ module RubyRest
     class Default
       
       # Configures the server name and port 
-      def self.with_server name, port
-        @host = name
+      def initialize( host, port )
+        @host = host
         @port = port
       end
       
-      # Returns the hostname of the service to 
-      # connect to
-      def self.host
-        @host
-      end
-      
-      # Returns the port number on which to 
-      # connect to
-      def self.port
-        @port 
+      # Encodes the specified path, by replacing spaces
+      # for the + character. The server will decode
+      def encode_path( path )
+        path.gsub( " ", "+" )
       end
       
       # Converts the specified hash of data into a
       # query string, then performs a GET http request.
       # The response body is returned as an an Atom document if 
       # the response status code is 200.
-      def retrieve( path, data, api_key )
+      def retrieve( path, data = nil, api_key = nil )
         path << to_query_string( data ) if data
         headers = prepare_headers( api_key )
-        rsp = http.get( path, headers )
+        rsp = http.get( encode_path( path ), headers )
         return to_xml( rsp ) if rsp.code.to_i == 200
       end
       
@@ -42,11 +36,11 @@ module RubyRest
       # simplified Atom Entry, then performs a POST http request.
       # The response body is returned as an an Atom Entry if 
       # the response status code is 201.
-      def create( path, data, api_key )
+      def create( path, data, api_key = nil )
         body = nil
         body = hash2entry( data ).to_s if data != nil
         headers = prepare_headers( api_key )
-        rsp = http.post( path, body, headers )
+        rsp = http.post( encode_path( path ), body, headers )
         return to_xml( rsp ) if rsp.code.to_i == 201
       end
       
@@ -54,21 +48,21 @@ module RubyRest
       # simplified Atom Entry, then performs a PUT http request.
       # The response body is returned as an an Atom Entry if 
       # the response status code is 200.
-      def update( path, data, api_key )
+      def update( path, data, api_key = nil)
         body = nil
         body = hash2entry( data ).to_s if data != nil
         headers = prepare_headers( api_key )
-        rsp = http.put( path, body, headers )
+        rsp = http.put( encode_path( path ), body, headers )
         return to_xml( rsp ) if rsp.code.to_i == 200
       end
       
       # Converts the specified hash of data into a
       # query string, then performs a DELETE http request.
       # This method simply returns the response status code
-      def delete( path, data, api_key )
+      def delete( path, data =nil, api_key = nil )
         path << to_query_string( data ) if data
         headers = prepare_headers( api_key )
-        rsp = http.delete( path, headers )
+        rsp = http.delete( encode_path( path ), headers )
         rsp.code.to_i
       end
       
@@ -81,7 +75,7 @@ module RubyRest
       # Convenience method that returns a new HTTP object
       # for each call
       def http
-        Net::HTTP.new( self.class.host, self.class.port )
+        Net::HTTP.new( @host, @port )
       end
       
       # Builds a headers hash, with the specified 
@@ -95,13 +89,9 @@ module RubyRest
       # Converts the specified hash of data into a simplified
       # Atom Entry document.
       def hash2entry( data )
-        doc = RubyRest::Atom::Entry::Document.new
-        entry = REXML::Element.new( "entry", doc  )
-        content = REXML::Element.new( "content", entry )
-        data.each { |name,value| 
-          body = REXML::Element.new( name.to_s, content )
-          body.text = value
-        }
+        doc = RubyRest::Atom::Document.new
+        content = doc.add_element( "entry" ).add_element( "rubyrest:content" )
+        data.each { |name,value| content.add_element( name.to_s ).add_text( value ) }
         return doc
       end
 
@@ -109,7 +99,7 @@ module RubyRest
       # which can be a Feed or Entry, or Service Document
       def to_xml( rsp )
         begin
-          RubyRest::Atom::Entry::Document.new( rsp.body ) if rsp.body
+          RubyRest::Atom::Document.new( rsp.body ) if rsp.body
         rescue => e
           puts "unable to parse response body: " + e.message
           puts "---- response body ----"