rubyrest 0.1.0 → 0.1.1

data/CHANGELOG

@@ -1,3 +1,11 @@
+== Release 0.1.1
+
+* New Application hierarchy introduces SimpleApplication and SecureApplication
+* Method RubyRest::Client::Default#hash2entry fixed and now more robust  
+* Method 'load' has been replaced by method 'single' when loading resources via the domain, so that we avoid name clashes with Sequel.
+* The 'service' and the 'model' are now merged into the 'domain'. This results in much simpler Ruby-on-Rest applications.
+* Sequel::Application now imports a <service>.sql at startup, if :destroy == true
+
 == Release 0.1.0
 
 * A rewritten from scratch architecture and implementation that offers: pluggability, better object orientation, thread safety and backwards incompatibility (sorry for this one!)

data/README

@@ -23,7 +23,7 @@ If you have any comments or suggestions please send an email to pedro dot gutier
 
   sudo gem install rubyrest
   
-=== Learning by example
+== Learning by example
 
 Maybe the easiest way to learn how Ruby-on-Rest works is to take a look at the following examples, included in the source distribution:
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "rubyrest"
-VERS = "0.1.0"
+VERS = "0.1.1"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Ruby-on-Rest: A simple REST framework for Ruby",
   "--opname", "index.html",

data/lib/rubyrest/application.rb

@@ -1,15 +1,12 @@
 module RubyRest
     
+    SYS_FILES = [ "application", "client" ].freeze
+    
     # Base Application class for all applications deployed
     # with Ruby-on-Rest
-    class Application
+    class AbstractApplication
       attr_reader :config
       
-      # Defines whether update and create operations should
-      # automatically load and create new domain model, and automatically
-      # bind values from the request body document. Can be disabled
-      # in subclasses.
-      def auto_bind; true end
       
       # To be overriden by applications that use databases 
       def init_database
@@ -19,35 +16,21 @@ module RubyRest
       def initialize( config )
         @config = config
         setup
-        register_model
-        register_resources
+        @resources_by_path = Hash.new
+        @resources_by_name = Hash.new
+        @resources_by_domain = Hash.new
+        register_domain
         register_formatters
         init_database
       end
       
       # Loads all the domain files provided by the developer
-      def register_model
-        path_to_model = @doc_base + "/domain"
-        Dir.foreach( path_to_model ) { |filename|
+      def register_domain
+        Dir.foreach( @doc_base ) { |filename|
           filename = File.basename( filename, ".rb" )
-          if !(File.basename( filename )[0] == ?.) && !FileTest.directory?( filename )
-            require path_to_model + "/" + filename
-          end
-        }
-      end
-      
-      # Loads all the resources configured under the 'resources'
-      # folder relative to the application doc base
-      def register_resources
-        @resources_by_path = Hash.new 
-        @resources_by_model = Hash.new 
-        path_to_resources = @doc_base + "/resources"
-        
-        Dir.foreach( @doc_base + "/resources" ) { |filename|
-          if !(File.basename( filename )[0] == ?.) && !FileTest.directory?( filename )
-            filename = File.basename( filename, ".rb" )
-            require path_to_resources + "/" + filename
-            register_resource( to_resource_class( filename ).new( self ) )
+          if !(filename[0] == ?.) && !FileTest.directory?( filename ) && !SYS_FILES.include?( filename )
+            require @doc_base + "/" + filename
+            register_resource( filename.to_s.intern  )
           end
         }
       end
@@ -64,7 +47,7 @@ module RubyRest
       
       # Resolves the Ruby-on-Rest resource descriptor for the 
       # specified request path
-      def resource_for_path( path )
+      def resource_by_path( path )
         mount_point = "/"
         path_tokens = path.split( "/" )
         mount_point = "/"+path_tokens[1] if path_tokens.length > 0
@@ -75,22 +58,39 @@ module RubyRest
       
       # Retrieves the Ruby-on-Rest resource descriptor for the specified
       # model object
-      def resource_for_model( model )
-        resource = @resources_by_model[model.class]
-        raise "no resource mounted for model #{model.class}" if !resource
+      def resource_by_domain( model )
+        resource = @resources_by_domain[model.class]
+        raise "no resource mounted for domain #{model.class}" if !resource
+        return resource
+      end
+      
+      def resource_by_name( name )
+        resource = @resources_by_name[name]
+        raise "no resource mounted for name #{name}" if !resource
         return resource
       end
       
-      # Registers a new resource instance
-      def register_resource( resource )
-        @resources_by_path[resource.class.mount_point] = resource
-        @resources_by_model[resource.model]=resource.class
-        puts "resource mounted: #{resource}"
+      # Registers a new resource for the given name
+      def register_resource( name )
+        puts "mounting resource: #{name} ..."
+        resource_klass = to_resource_class( name )
+        domain_klass = to_domain_class( name )
+        resource_klass.set_domain domain_klass
+        resource = resource_klass.new( self )
+        @resources_by_path[resource_klass.mount_point] = resource
+        @resources_by_domain[domain_klass]=resource
+        @resources_by_name[name]=resource
+        puts "resource mounted: #{resource} [OK]" 
       end
       
-      # Returns the class name for the given resource name
+      # Returns the resource class name for the given  name
       def to_resource_class( name )
-        Class.by_name( @config[:module].capitalize + "::" + @config[:service].capitalize + "::" + name.to_s.capitalize )
+        Class.by_name( @config[:module].capitalize + "::" + @config[:service].capitalize + "::Resource::" + name.to_s.capitalize )
+      end
+      
+      # Returns the domain class name for the given name
+      def to_domain_class( name )
+        Class.by_name( @config[:module].capitalize + "::" + @config[:service].capitalize + "::Domain::" + name.to_s.capitalize )
       end
       
       # Register all the formatters supported by the application
@@ -106,28 +106,115 @@ module RubyRest
         @formatters[params[:format]]||@formatters[:atom]
       end
       
+      def render_model( params, model )
+        formatter( params ).format( model, params )
+      end
+      
+      # Tells whether the specified model will be rendered
+      # as a feed or entry. To be subclassed
+      def is_a_collection( model )
+        model == nil || model.is_a?( Array )
+      end
+      
+      # Implement me in subclasses
+      def is_a_service_doc( model )
+        
+      end
+      
+      
+    end
+    
+    # Basic CRUD application 
+    class SimpleApplication < RubyRest::AbstractApplication
+      
+      # Invoked by the web layer, on a GET request. 
+      # Retrieves the collection or resource, and formats the 
+      # result as a feed, entry or service document
+      def retrieve( params )
+        res = resource_by_path( params[:path] )
+        render_model( params, res.domain.retrieve( params[:target], params[:property] ) )
+      end
+      
+      # Invoked by the web layer, on a POST request.
+      # This method delegates to the resource's service and provides 
+      # a fresh new model object populated with the data 
+      # found in the request body.
+      def create( params )
+        res = resource_by_path( params[:path] )
+        render_model( params, res.domain.create( params[:body] ) )
+      end
+      
+      # Invoked by the web layer, on a PUT request
+      # This method delegates to the resource's service and provides an existing model
+      # object, loaded and populated with the data found in the request body.
+      def update( params )
+        res = resource_by_path( params[:path] )
+        render_model( params, res.domain.update( params[:target], params[:body] ) )
+      end
+      
       # Invoked by the web layer, on a DELETE request
       def delete( params )
-        res = resource_for_path( params[:path] )
-        res.service.delete( res.service.load( params[:target], params[:principal] ), params[:principal] )
+        res = resource_by_path( params[:path] )
+        res.domain.delete( params[:target] )
       end
       
-      def render_model( params, model )
-        formatter( params ).format( model, params )
+      
+    end
+    
+    
+    
+    # Specialization of a Simple application, that introduces the notion 
+    # of security services and principals. It overrides the retrieve, create, update
+    # and delete methods and adds some extras like automatic binding.
+    class SecureApplication < RubyRest::SimpleApplication
+      
+      # Defines whether update and create operations should
+      # automatically load and create new domain model, and automatically
+      # bind values from the request body document. Can be disabled
+      # in subclasses.
+      def auto_bind; true end
+      
+      # Builds a new secured application and register
+      # its security service
+      def initialize( config )
+        super( config )
+        register_security
+      end
+      
+      # Register the security service, if specified in the 
+      # application configuration hash
+      def register_security
+        raise "no security service was defined in application #{self}" if !@config[:security_service]
+        client_class = Class.by_name( (@config[:security_module]||@config[:module]).to_s.capitalize + "::" + @config[:security_service].to_s.capitalize + "::Client" )
+        @security = client_class.new( @config[:security_host]||"localhost", @config[:security_port] )
+      end
+      
+      # Returns the security service, of nil if not configured
+      def security
+        @security
+      end
+      
+      # Resolves the principal, by inoking the security service
+      def resolve_principal( params )
+        principal = @security.principal( params[:authkey] ) 
+        raise "No principal was found for authentication key: #{params[:authkey]}" if !principal
+        params[:principal]=principal
+        return params
       end
       
       # Invoked by the web layer, on a GET request. 
       # Retrieves the collection or resource, and formats the 
       # result as a feed, entry or service document
       def retrieve( params )
-        res = resource_for_path( params[:path] )
+        params = resolve_principal( params )
+        res = resource_by_path( params[:path] )
         if params[:target] == nil
-          objects = res.service.list( params[:principal] )
+          objects = res.domain.list( params[:principal] )
         else
           if params[:property] == nil
-            objects = res.service.load( params[:target], params[:principal] )
+            objects = res.domain.single( params[:target], params[:principal] )
           else
-            objects = res.service.list_related( params[:target], params[:property], params[:principal] )
+            objects = res.domain.list_related( params[:target], params[:property], params[:principal] )
           end
         end
         render_model( params, objects )
@@ -138,9 +225,10 @@ module RubyRest
       # a fresh new model object populated with the data 
       # found in the request body.
       def create( params )
-        res = resource_for_path( params[:path] )
-        params[:body] = res.bind( res.service.create( params[:principal] ), params[:body] ) if auto_bind == true
-        object = res.service.save_new( params[:body], params[:principal] )
+        params = resolve_principal( params )
+        res = resource_by_path( params[:path] )
+        params[:body] = res.bind( res.domain.create( params[:principal] ), params[:body] ) if auto_bind == true
+        object = res.domain.save_new( params[:body], params[:principal] )
         render_model( params, object )
       end
       
@@ -148,30 +236,26 @@ module RubyRest
       # This method delegates to the resource's service and provides an existing model
       # object, loaded and populated with the data found in the request body.
       def update( params )
-        res = resource_for_path( params[:path] )
-        params[:body] = res.bind( res.service.load( params[:target], params[:principal] ), params[:body] ) if auto_bind == true
-        object = res.service.save_existing( params[:target], params[:body], params[:principal] )
+        params = resolve_principal( params )
+        res = resource_by_path( params[:path] )
+        params[:body] = res.bind( res.domain.single( params[:target], params[:principal] ), params[:body] ) if auto_bind == true
+        object = res.domain.save_existing( params[:target], params[:body], params[:principal] )
         render_model( params, object )
       end
       
-      # Tells whether the specified model will be rendered
-      # as a feed or entry. To be subclassed
-      def is_a_collection( model )
-        model == nil || model.is_a?( Array )
-      end
-      
-      # Implement me in subclasses
-      def is_a_service_doc( model )
-        
+      # Invoked by the web layer, on a DELETE request
+      def delete( params )
+        params = resolve_principal( params )
+        res = resource_by_path( params[:path] )
+        res.domain.delete( res.domain.single( params[:target], params[:principal] ), params[:principal] )
       end
       
     end
     
-    
-    # Specialization of a basic application, that provides support for 
+    # Specialization of a secure application, that provides support for 
     # Sequel (http://sequel.rubyforge.org) configuration at startup by 
     # implementing the 'init_database' method
-    class SequelApplication < RubyRest::Application
+    class SequelApplication < RubyRest::SecureApplication
       
       # Specifies the list of resources to be persisted
       def self.with_persistent_resources *resources
@@ -184,26 +268,37 @@ module RubyRest
         return @persistent
       end
       
+      # Builds the path to the sqlite database file
+      def to_database_path
+        "#{@config[:workdir]}/#{@config[:service]}-#{@config[:database]}.database"
+      end
+      
       # Connects all persistent resources to the database and optionnally
       # recreates the database schema. For the moment this only 
       # works with PostgreSQL databases
       def init_database
         @db = Sequel::Postgres::Database.new( @config )
+        
+        #@db = Sequel.open "sqlite:///#{to_database_path}"
         self.class.persistent_resources.each{ |r| 
-          to_resource_class( r ).model.db=@db 
+          resource = resource_by_name( r )
+          resource.domain.db=@db 
+          if @config[:destroy]
+            resource.domain.recreate_table 
+          end
         }
-        if @config[:destroy]
-          self.class.persistent_resources.each{ |r| 
-            to_resource_class( r ).model.recreate_table
-          }
-          puts "importing initial data..."
-          import_data 
-        end
+        import_data if @config[:destroy]
       end
       
       # PLease override this in subclasses
       def import_data
-        
+        begin 
+          import_file = @config[:resources_dir]||"" + @config[:service] + ".sql"
+          IO.readlines( import_file, ";" ).each{ |insert| @db.execute insert }
+        rescue => e
+          puts "skipping import of #{import_file}. Reason: #{e.message}"
+        end
+        puts "data import complete from #{import_file} ..."
       end
       
       # Tells whether the specified model will be rendered

data/lib/rubyrest/atom.rb

@@ -116,7 +116,9 @@ module RubyRest
       end
       
       def xml_value( object, options )
-        return object.get_value( tag( options ), options[:required]||true )
+        required = true
+        required = options[:required] if options[:required] != nil
+        return object.get_value( tag( options ), required )
       end
       
       def bind( object, options, value  )
@@ -147,11 +149,15 @@ module RubyRest
     
     class DateProperty < SimpleProperty
       
-      def date2string( date )
+      def self.format_date( date )
         date = Time.now if !date
         date.strftime( ATOM_DATE_FORMAT )
       end
       
+      def date2string( date )
+        self.class.format_date( date )
+      end
+      
       def string2date( date )
         Date.strptime( value, ATOM_DATE_FORMAT )
       end
@@ -167,9 +173,18 @@ module RubyRest
     end
     
     class DomainFormatter
+      
+      # Creates a new formatter, as a child of the 
+      # specified parent formatter
       def initialize( parent )
         @parent = parent
       end
+      
+      # shortcut to the application
+      def app
+        @parent.app
+      end
+      
     end
     
     class FeedFormatter < DomainFormatter
@@ -198,22 +213,22 @@ module RubyRest
       end
       
       def format_entry( object, xml, params )
-        resource = @parent.app.resource_for_model( object )
+        resource = @parent.app.resource_by_domain( object )
         raise "no resource found for entry #{object}" if !resource
-        
         entry = xml.add_element( "entry", NAMESPACES )
         entry.add_element( "title" )
-        entry.add_element( "author" )
-        entry.add_element( "updated" )
+        entry.add_element( "author" ).add_element( "name" ).add_text( object.author )
+        entry.add_element( "updated" ).add_text( DateProperty.format_date( object.updated ) )
         entry.add_element( "id" )
         entry.add_element( "summary" )
         
-        resource.links.each{ |link|
-          entry.add_element( "link", link )
+        resource.class.links.each{ |link|
+          render = params[:principal].profile.split( "," ).include?( link[:role].to_s )
+          entry.add_element( "link", { "title" => link[:title].to_s, "rel" => link[:rel].to_s} ) if render
         }
         
         content = entry.add_element( "rubyrest:content" )
-        resource.props.each{ |map| 
+        resource.class.props.each{ |map| 
           @parent.property( map ).format( object, map, content ) 
         }
       end
@@ -252,6 +267,7 @@ module RubyRest
       
       def add( uri, title, accept )
         @collections << ServiceCollection.new( uri, title, accept )
+        return self
       end
       
     end

data/lib/rubyrest/client.rb

@@ -91,7 +91,7 @@ module RubyRest
       def hash2entry( data )
         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 ) }
+        data.each { |name,value| content.add_element( name.to_s ).add_text( value.to_s ) }
         return doc
       end
 

data/lib/rubyrest/resource.rb

@@ -9,14 +9,19 @@ module RubyRest
         @app = app
       end
       
-      # Convenience method
-      def service
-        self.class.service
+      # Sets the domain implementation for this resource
+      def self.set_domain domain_klass
+        @domain = domain_klass
+      end
+      
+      # Returns the domain implementation
+      def self.domain
+        @domain
       end
       
       # Convenience method
-      def model
-        self.class.model
+      def domain
+        self.class.domain
       end
       
       # Defines the url type the resource is going to 
@@ -29,22 +34,6 @@ module RubyRest
         @mount_point
       end
       
-      def self.for_model model_klass
-        @model = model_klass
-      end
-      
-      def self.model
-        @model || Class.by_name( self.name + "Model" )
-      end
-      
-      def self.for_service service_klass
-        @service = service_klass
-      end
-      
-      def self.service
-        @service || Class.by_name( self.name + "Service" )
-      end
-      
       def self.atom modifiers
         self.props << modifiers
       end
@@ -79,7 +68,7 @@ module RubyRest
       
       # String representation of a resource
       def to_s
-        "path #{self.class.mount_point}, service #{self.class.service}, model #{self.class.model}"
+        "path #{self.class.mount_point}, domain #{self.domain}"
       end
       
   end

data/lib/rubyrest/webrick.rb

@@ -48,6 +48,7 @@ module RubyRest
       def args( request )
         args = Hash.new
         url_tokens = decode_path( request.path ).split( "/")
+        args[:authkey] = request["token"]
         args[:target] = url_tokens[2] if url_tokens.length>2
         args[:property] = url_tokens[3] if url_tokens.length>3
         args[:path] = request.path
@@ -58,6 +59,7 @@ module RubyRest
       def do_GET( request, response )
         params = args(request )
         response.status = 200
+        params[:action]=:retrieve
         xml = @app.retrieve( params )
         response["content-type"]=params[:content_type]
         xml.write( response.body )  
@@ -66,6 +68,7 @@ module RubyRest
       def do_POST( request, response )
         params = args(request )
         response.status = 201
+        params[:action]=:create
         xml = @app.create( params )
         response["content-type"]=params[:content_type]
         xml.write( response.body )
@@ -74,6 +77,7 @@ module RubyRest
       def do_PUT( request, response )
         params = args(request )
         response.status = 200
+        params[:action]=:update
         xml = @app.update( params )
         response["content-type"]=params[:content_type]
         xml.write( response.body )
@@ -82,6 +86,7 @@ module RubyRest
       def do_DELETE( request, response )
         params = args(request )
         response.status = 200
+        params[:action]=:delete
         @app.delete( params )
       end
       

data/lib/rubyrest.rb

@@ -5,6 +5,7 @@
 require "rubygems"
 require "sequel"
 require "sequel/postgres"
+require "sequel/sqlite"
 require "extensions/all"
 require "rexml/document"
 require "webrick"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: rubyrest
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-date: 2007-06-04 00:00:00 +02:00
+  version: 0.1.1
+date: 2007-06-10 00:00:00 +02:00
 summary: REST framework for Ruby.
 require_paths: 
 - lib