rubyrest 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,15 @@
+== Release 0.2.0
+
+* The Resource infrastructure has been almost rewritten from scratch. Ruby-on-Rest applications are now much easier to write.
+* Atom is now deprecated. The default formatter is now based on Yaml.
+* Simpler support for Sequel based applications
+* The Hello sample app now uses RSpec to describe its behaviour and provides a starting point for developing new Ruby-on-Rest applications.
+
+== Release 0.1.2
+
+* Sequel:Application now supports SQLite rather than PostgreSQL, plus a better database import filename construction and logging at startup.
+* The application is now injected into Domain classes, so the domain can access the application's global configuration (Domain must define #app and #app= methods).
+
 == Release 0.1.1
 
 * New Application hierarchy introduces SimpleApplication and SecureApplication

data/README

@@ -27,7 +27,11 @@ If you have any comments or suggestions please send an email to pedro dot gutier
 
 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:
 
-* The 'Hello' application can be used as a skeletton for new Ruby-on-Rest applications
+* The 'Hello' application can be used as a skeletton for new Ruby-on-Rest applications. You can test it by running the specifications:
+
+	spec hello_spec.rb
+	
+and hopefully everything goes green :D
 
 == Starting the service
 
@@ -45,13 +49,8 @@ Ruby-on-Rest can be embedded in Ruby code. This is useful for testing purposes:
 	
   config = {
 
-  	"module" => "acme",
-  	"service" => "hello",
-  	"version" => "v1.0",
-  	"webserver" => :webrick,
-  	"destroy" => false ,
-  	"daemon" => true,
-  	"http_port" => 10000
+  	( ... config options here, see the hello app to get started ...)
+  
   }
 	
   engine = RubyRest::Engine.new( config )

data/Rakefile

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

data/bin/rubyrest

@@ -23,6 +23,7 @@ else
   # deploy specific configuration, and build a hash out of it
   params = YAML::load_file( "#{service}_#{deploy_mode}.yaml" )
   params[ "service" ] = service
+  params[ "deploy_mode" ] = deploy_mode
   
   engine = RubyRest::Engine.new( params )
   engine.start

data/lib/rubyrest.rb

@@ -3,8 +3,8 @@
 # Entry point to the framework.
 # Loads all the files under the 'rubyrest' subdirectory
 require "rubygems"
+require "logger"
 require "sequel"
-require "sequel/postgres"
 require "sequel/sqlite"
 require "extensions/all"
 require "rexml/document"
@@ -18,4 +18,5 @@ require File.join( dir, "resource" )
 require File.join( dir, "application" )
 require File.join( dir, "engine" )
 require File.join( dir, "atom" )
+require File.join( dir, "yaml" )
 require File.join( dir, "client" )

data/lib/rubyrest/application.rb

@@ -1,43 +1,116 @@
 module RubyRest
     
+    # Logger configuration, can be reused in RubyRest and Non RubyRest applications
+    module ApplicationLogger
+      
+      def init_logger
+        case @config[:deploy_mode]
+          when "dev"
+            @logger = Logger.new( STDOUT ) 
+            @logger.level = Logger::DEBUG
+          when "live"
+            raise "you need to specify a logfile when deploying in LIVE mode" if !@config[:log]
+            @logger = Logger.new( @config[:log], 10, 1024000 ) 
+            @logger.level = Logger::ERROR
+          else
+            @logger = Logger.new( STDOUT ) 
+            @logger.level = Logger::DEBUG
+        end
+        @logger.info "log level set to #{@logger.level} [OK]" if @logger.info?
+      end
+      
+    end
+    
+    
+    
     SYS_FILES = [ "application", "client" ].freeze
     
     # Base Application class for all applications deployed
     # with Ruby-on-Rest
     class AbstractApplication
-      attr_reader :config
+      include RubyRest::ApplicationLogger
       
+      attr_reader :config, :logger
       
       # To be overriden by applications that use databases 
       def init_database
+        
+      end
       
+      # To be overriden
+      def create_tables
+        
       end
       
       def initialize( config )
         @config = config
-        setup
-        @resources_by_path = Hash.new
-        @resources_by_name = Hash.new
-        @resources_by_domain = Hash.new
-        register_domain
-        register_formatters
+        init_logger
         init_database
+        if @config[:destroy]==true
+          drop_schema
+          create_schema
+          load_initial_data if self.respond_to?( :load_initial_data )
+        end
+        register_resources
+        register_formatters
+        register_services
       end
       
-      # Loads all the domain files provided by the developer
-      def register_domain
-        Dir.foreach( @doc_base ) { |filename|
-          filename = File.basename( filename, ".rb" )
-          if !(filename[0] == ?.) && !FileTest.directory?( filename ) && !SYS_FILES.include?( filename )
-            require @doc_base + "/" + filename
-            register_resource( filename.to_s.intern  )
-          end
+      # Checks the configuration and issues an error if the specified
+      # key was not found
+      def check_config( key )
+        raise "missing configuration key: #{key}" if !@config[key]
+      end
+      
+      # Specifies the list of resources to be persisted
+      def self.with_resources *resources
+        @resources = resources
+      end
+      
+      # Returns the list of persistent resources
+      def self.resources
+        @resources = [] if !@resources
+        return @resources
+      end
+      
+      def register_resources
+        @resources = Hash.new
+        self.class.resources.each{ |name|
+          resource_klass = to_resource_class( name )
+          resource = resource_klass.new( self, name )
+          @resources[resource_klass.mount_point]=resource
+          @resources[name]=resource
+          @logger.info "resource mounted: #{resource} [OK]" if @logger.info?
         }
       end
       
-      # Please override me if needed
-      def setup
+      # Registers a single service
+      def register_service( service )
+        module_key = "#{service}_module".intern
+        module_key = :module if @config[module_key] == nil
+        
+        host_key = "#{service}_host".intern
+        port_key = "#{service}_port".intern
+        role_key = "#{service}_role".intern
         
+        check_config( role_key )
+        check_config( port_key )
+         
+        client_class = to_service_class( @config[module_key], service )
+        @services[@config[role_key].intern] = client_class.new( @config[host_key]||"localhost", @config[port_key] )
+        
+        @logger.info "service registered #{service} as #{@config[role_key].intern}" if @logger.info?
+      end
+      
+      # Registers all the services configured at startup
+      def register_services
+        @services = Hash.new
+        @config[:services].each{ |service| register_service( service ) } if @config[:services] != nil 
+      end
+      
+      # Returns a service, by name
+      def service( name )
+        @services.fetch( name )
       end
       
       # Returns the description and version
@@ -51,65 +124,57 @@ module RubyRest
         mount_point = "/"
         path_tokens = path.split( "/" )
         mount_point = "/"+path_tokens[1] if path_tokens.length > 0
-        resource = @resources_by_path[mount_point]
-        raise "no resource mounted at #{mount_point}" if !resource
-        return resource
-      end
-      
-      # Retrieves the Ruby-on-Rest resource descriptor for the specified
-      # model object
-      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
+        resource(mount_point)
       end
       
-      # 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]" 
+      def resource( key )
+        raise "no resource found at key: #{key}" if @resources.key?( key ) == false
+        @resources[key]
       end
       
       # Returns the resource class name for the given  name
       def to_resource_class( name )
-        Class.by_name( @config[:module].capitalize + "::" + @config[:service].capitalize + "::Resource::" + name.to_s.capitalize )
+        Class.by_name( @config[:module].to_s.capitalize + "::" + @config[:service].to_s.capitalize + "::" + 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 )
+      def to_service_class( module_name, service_name )
+        Class.by_name( module_name.to_s.capitalize + "::" + service_name.to_s.capitalize + "::Client" )
       end
       
       # Register all the formatters supported by the application
       # For the moment, only the Atom representation of resources
       # is supported
       def register_formatters
-        @formatters = { :atom => RubyRest::Atom::Formatter.new( self ) }
+        @formatters = { 
+          :atom => RubyRest::Atom::Formatter.new( self ),
+          :yaml => RubyRest::Format::Yaml.new( self )
+        }
+      end
+      
+      def parse_request( params, request )
+        data = formatter( params ).parse_request( request.body )
+        @logger.info( data ) if @logger.info?
+        return data
       end
       
+      
       # Resolves the formatter to use in the returned
       # representation
       def formatter( params )
-        @formatters[params[:format]]||@formatters[:atom]
+        @formatters[params[:format]]||@formatters[:yaml]
       end
       
       def render_model( params, model )
         formatter( params ).format( model, params )
       end
       
+      # Binds values found in the specified source in
+      # properties of the specified domain object
+      # Delegates to the formatter
+      def bind( object, params )
+        formatter( params ).bind( object, params[:body], params )
+      end
+      
       # Tells whether the specified model will be rendered
       # as a feed or entry. To be subclassed
       def is_a_collection( model )
@@ -118,55 +183,15 @@ module RubyRest
       
       # Implement me in subclasses
       def is_a_service_doc( model )
-        
+        model != nil && model.is_a?( RubyRest::Atom::ServiceDocument )
       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_by_path( params[:path] )
-        res.domain.delete( params[:target] )
-      end
-      
-      
-    end
-    
-    
-    
-    # Specialization of a Simple application, that introduces the notion 
+    # Specialization of an Abstract 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
+    class SecureApplication < RubyRest::AbstractApplication
       
       # Defines whether update and create operations should
       # automatically load and create new domain model, and automatically
@@ -178,25 +203,24 @@ module RubyRest
       # its security service
       def initialize( config )
         super( config )
-        register_security
+        register_security if !@config[:disable_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] )
+        if !@services[:security]
+          raise "no security service was defined in application #{self}" 
+        end
       end
       
       # Returns the security service, of nil if not configured
       def security
-        @security
+        @services[:security]
       end
       
       # Resolves the principal, by inoking the security service
       def resolve_principal( params )
-        principal = @security.principal( params[:authkey] ) 
+        return params if @config[:disable_security]
+        principal = security.principal( params[:authkey] ) 
         raise "No principal was found for authentication key: #{params[:authkey]}" if !principal
         params[:principal]=principal
         return params
@@ -208,13 +232,15 @@ module RubyRest
       def retrieve( params )
         params = resolve_principal( params )
         res = resource_by_path( params[:path] )
+        params[:resource]=res
+        
         if params[:target] == nil
-          objects = res.domain.list( params[:principal] )
+          objects = res.list( params[:principal] )
         else
           if params[:property] == nil
-            objects = res.domain.single( params[:target], params[:principal] )
+            objects = res.single( params[:target], params[:principal] )
           else
-            objects = res.domain.list_related( params[:target], params[:property], params[:principal] )
+            objects = res.list_related( params[:target], params[:property], params[:principal] )
           end
         end
         render_model( params, objects )
@@ -227,8 +253,9 @@ module RubyRest
       def create( params )
         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] )
+        params[:resource]=res
+        params[:body] = bind( res.new_instance( params[:principal] ), params ) if auto_bind == true
+        object = res.save_new( params[:body], params[:principal] )
         render_model( params, object )
       end
       
@@ -238,8 +265,9 @@ module RubyRest
       def update( params )
         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] )
+        params[:resource]=res
+        params[:body] = bind( res.single( params[:target], params[:principal] ), params ) if auto_bind == true
+        object = res.save_existing( params[:body], params[:principal] )
         render_model( params, object )
       end
       
@@ -247,7 +275,8 @@ module RubyRest
       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] )
+        params[:resource]=res
+        res.delete_existing( res.single( params[:target], params[:principal] ), params[:principal] )
       end
       
     end
@@ -257,59 +286,42 @@ module RubyRest
     # implementing the 'init_database' method
     class SequelApplication < RubyRest::SecureApplication
       
-      # Specifies the list of resources to be persisted
-      def self.with_persistent_resources *resources
-        @persistent = resources
-      end
-      
-      # Returns the list of persistent resources
-      def self.persistent_resources
-        @persistent = [] if !@persistent
-        return @persistent
-      end
+      attr_reader :db
       
-      # Builds the path to the sqlite database file
-      def to_database_path
-        "#{@config[:workdir]}/#{@config[:service]}-#{@config[:database]}.database"
+      # Tells whether the specified model will be rendered
+      # as a feed or entry. To be subclassed
+      def is_a_collection( model )
+        super( model ) || model.is_a?( Sequel::Dataset )
       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| 
-          resource = resource_by_name( r )
-          resource.domain.db=@db 
-          if @config[:destroy]
-            resource.domain.recreate_table 
-          end
-        }
-        import_data if @config[:destroy]
+        check_config( :database )
+        @db = Sequel.open( "sqlite:///#{@config[:database]}", :max_connections => 10, :logger => @logger )
       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}"
+      # Convenience method that hides that safely
+      # drops a table
+      def drop_table( name )
+        
+        begin
+          @db << "DROP TABLE #{name}"
+        rescue => e 
+          @logger.warn e.message if @logger.warn?
         end
-        puts "data import complete from #{import_file} ..."
+        
       end
       
-      # Tells whether the specified model will be rendered
-      # as a feed or entry. To be subclassed
-      def is_a_collection( model )
-        super( model ) || model.is_a?( Sequel::Dataset )
+      # Convenience method that safely drops a view
+      def drop_view( name )
+        
+        begin
+          @db << "DROP VIEW #{name}"
+        rescue => e 
+          @logger.warn e.message if @logger.warn?
+        end
+        
       end
       
-      def is_a_service_doc( model )
-        super( model ) || model.is_a?( RubyRest::Atom::ServiceDocument )
-      end
       
     end
     

data/lib/rubyrest/atom.rb

@@ -15,22 +15,14 @@ module RubyRest
     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
+    module Extensions
       
       # 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
+        raise "missing value at location #{location} in #{self.to_s}" if required && (!value || value.length == 0)
         return value
       end
       
@@ -38,18 +30,27 @@ module RubyRest
         get_text( "/entry/rubyrest:content/#{name}" ).value = value
       end
 
-      # Shortcut for the id element contained
-      # within the content.
-      def id
-        text( "/entry/rubyrest:content/id" )
+      def method_missing( name, *args )
+        get_value( name )
       end
-
-      # Overrides the default implementation
-      # by returning a new Ruby-on-Rest Atom Document
-      def clone
-        self.class.new self.to_s
+      
+      def new_copy
+        REXML::Document.new self.to_s
       end
-
+      
+    end
+    
+    class REXML::Element
+      include RubyRest::Atom::Extensions
+      
+    end
+    
+    # Ruby-on-Rest specialization of the REXML document
+    # class. Adds some convenient ways of accessing data from 
+    # a Atom document
+    class REXML::Document
+      include RubyRest::Atom::Extensions
+    
     end
     
     # Main Atom formatter class, composed of more specialized objects
@@ -71,6 +72,8 @@ module RubyRest
         @props=Hash.new
         @props[:simple]=SimpleProperty.new( self )
         @props[:date]=DateProperty.new( self )
+        @props[:nested]=NestedProperty.new( self )
+        
       end
       
       # Resolves the specified name into a formatter
@@ -106,13 +109,18 @@ module RubyRest
         @parent = parent
       end
       
+      # Shortcut method 
+      def app
+        @parent.app
+      end
+      
       def tag( options )
         value = options[:tag]||options[:property]
         return value.to_s
       end
       
       def object_value( object, options )
-        object.send options[:property]
+        object[ options[:property] ]
       end
       
       def xml_value( object, options )
@@ -122,7 +130,7 @@ module RubyRest
       end
       
       def bind( object, options, value  )
-        object.send options[:property].to_s + "=", value
+        object[ options[:property] ]=value
       end
       
       def parse( object, options, xml )
@@ -151,6 +159,7 @@ module RubyRest
       
       def self.format_date( date )
         date = Time.now if !date
+        date = Time.at( date ) if date.is_a?( Bignum )
         date.strftime( ATOM_DATE_FORMAT )
       end
       
@@ -158,8 +167,9 @@ module RubyRest
         self.class.format_date( date )
       end
       
-      def string2date( date )
-        Date.strptime( value, ATOM_DATE_FORMAT )
+      def string2date( str )
+        date = Date.strptime( str, ATOM_DATE_FORMAT )
+        Time.gm( date.year, date.month, date.day, 0, 0, 0, 0 ).to_i
       end
       
       def value_from_model( options, object )
@@ -172,6 +182,28 @@ module RubyRest
       
     end
     
+    
+    class NestedProperty < SimpleProperty
+      
+      NESTED_PROPERTY_SEPARATOR = '_'.freeze
+      
+      def bind( object, options, value  )
+        prop = options[:property]
+        tokens = prop.to_s.split( NESTED_PROPERTY_SEPARATOR )
+        property = tokens[0].intern
+        nested_prop = tokens[1]
+        object[property]= app.resource( property ).method( "first_by_#{nested_prop}").call( value )[:id]
+      end
+      
+      #def object_value( object, options )
+      #  prop = options[:property]
+      #  value = object
+      #  prop.to_s.split( NESTED_PROPERTY_SEPARATOR ).each{ |token|  value = value.send token.to_s }
+      #  return value
+      #end
+      
+    end
+    
     class DomainFormatter
       
       # Creates a new formatter, as a child of the 
@@ -213,17 +245,17 @@ module RubyRest
       end
       
       def format_entry( object, xml, params )
-        resource = @parent.app.resource_by_domain( object )
+        resource = params[:resource]
         raise "no resource found for entry #{object}" if !resource
         entry = xml.add_element( "entry", NAMESPACES )
         entry.add_element( "title" )
-        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( "author" ).add_element( "name" ).add_text( object[:modifiedby] )
+        entry.add_element( "updated" ).add_text( DateProperty.format_date( object[:modified] ) )
         entry.add_element( "id" )
         entry.add_element( "summary" )
         
         resource.class.links.each{ |link|
-          render = params[:principal].profile.split( "," ).include?( link[:role].to_s )
+          render = link[:role] == nil || 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
         }
         

data/lib/rubyrest/client.rb

@@ -7,7 +7,7 @@ module RubyRest
     # Default client for web services deployed with 
     # Ruby-on-Rest. Translates create, retrieve, update and
     # delete methods into POST, GET, PUT and DELETE http requests
-    class Default
+    class Abstract
       
       # Configures the server name and port 
       def initialize( host, port )
@@ -29,7 +29,7 @@ module RubyRest
         path << to_query_string( data ) if data
         headers = prepare_headers( api_key )
         rsp = http.get( encode_path( path ), headers )
-        return to_xml( rsp ) if rsp.code.to_i == 200
+        return hidrate_data( rsp ) if rsp.code.to_i == 200
       end
       
       # Converts the specified hash of data into a
@@ -38,10 +38,10 @@ module RubyRest
       # the response status code is 201.
       def create( path, data, api_key = nil )
         body = nil
-        body = hash2entry( data ).to_s if data != nil
+        body = serialize_data( data ).to_s if data != nil
         headers = prepare_headers( api_key )
         rsp = http.post( encode_path( path ), body, headers )
-        return to_xml( rsp ) if rsp.code.to_i == 201
+        return hidrate_data( rsp ) if rsp.code.to_i == 201
       end
       
       # Converts the specified hash of data into a
@@ -50,10 +50,10 @@ module RubyRest
       # the response status code is 200.
       def update( path, data, api_key = nil)
         body = nil
-        body = hash2entry( data ).to_s if data != nil
+        body = serialize_data( data ).to_s if data != nil
         headers = prepare_headers( api_key )
         rsp = http.put( encode_path( path ), body, headers )
-        return to_xml( rsp ) if rsp.code.to_i == 200
+        return hidrate_data( rsp ) if rsp.code.to_i == 200
       end
       
       # Converts the specified hash of data into a
@@ -63,7 +63,8 @@ module RubyRest
         path << to_query_string( data ) if data
         headers = prepare_headers( api_key )
         rsp = http.delete( encode_path( path ), headers )
-        rsp.code.to_i
+        raise "error when deleting" if rsp.code.to_i != 200
+        return nil
       end
       
       # Convenience method that returns the 
@@ -83,42 +84,70 @@ module RubyRest
       def prepare_headers( api_key = nil )
         headers = { "Content-Type" => "text/xml; charset=utf-8" }
         headers[ "token" ] = api_key if api_key != nil 
+        headers["format"]=@format
         return headers
       end
       
-      # Converts the specified hash of data into a simplified
-      # Atom Entry document.
-      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.to_s ) }
-        return doc
+      # Reusable method that creates a query string
+      # with the specified hash of data
+      def to_query_string( data )
+        qs = "?"
+        params.each{ |k,v| qs << "#{k}=#{v}&" }
+        qs.chop!
+      end
+      
+    end
+    
+    
+    class Yaml < Abstract
+      
+      def initialize( host, port )
+        super( host, port )
+        @format = "yaml"
+      end
+      
+      def hidrate_data( response )
+        YAML::load( response.body ) if response.body
+      end
+      
+      def serialize_data( hash )
+        hash.to_yaml 
       end
-
-      # Parses the response body string as a Ruby-on-Rest XML Document,
-      # which can be a Feed or Entry, or Service Document
-      def to_xml( rsp )
+      
+    end
+    
+    
+    class Atom < Abstract
+    
+      def initialize( host, port )
+        super( host, port )
+        @format = "atom"
+      end
+      
+      def hidrate_data( response )
         begin
-          RubyRest::Atom::Document.new( rsp.body ) if rsp.body
+          REXML::Document.new( response.body ) if response.body
         rescue => e
           puts "unable to parse response body: " + e.message
           puts "---- response body ----"
-          puts rsp.body
+          puts response.body
           puts "-----------------------"
           return nil
         end
       end
-
-      # Reusable method that creates a query string
-      # with the specified hash of data
-      def to_query_string( data )
-        qs = "?"
-        params.each{ |k,v| qs << "#{k}=#{v}&" }
-        qs.chop!
+      
+      def serialize_data( hash )
+        doc = REXML::Document.new
+        content = doc.add_element( "entry" ).add_element( "rubyrest:content" )
+        hash.each { |name,value| content.add_element( name.to_s ).add_text( value.to_s ) }
+        return doc
       end
+        
+      
       
     end
     
+    
   end
   
 end

data/lib/rubyrest/engine.rb

@@ -12,7 +12,7 @@ module RubyRest
     # the statement +require @service+ works.
     def initialize( config )
       params = intern_config( config )
-      require params[:service]
+      require_library( params )
       @app = Class.by_name( params[:module].capitalize + "::" + params[:service].capitalize + "::Application"  ).new( params )
       if params[:daemon ] != nil
         @daemon = params[:daemon ] 
@@ -20,6 +20,10 @@ module RubyRest
       @server = Class.by_name( "RubyRest::" + params[:webserver].to_s.capitalize + "::Server" ).new( @app )
     end
     
+    # Requires the library params
+    def require_library( params )
+      require params[:gem] if params[:gem]
+    end
     
     # Returns a new hash, with all the keys as symbols
     def intern_config( hash )

data/lib/rubyrest/resource.rb

@@ -1,27 +1,25 @@
 module RubyRest
+  
+  module Resource
+  
     
-  # Base REST Resource class that acts as a wrapper for the actual
-  # business logic, data formatting (response time) and validations (request time)
-  class Resource
+    
+    # Base REST Resource class that acts as a wrapper for the actual
+    # business logic, data formatting (response time) and validations (request time)
+    class Base
+      
+      attr_reader :app, :name
       
       # Creates a new resource, under the given application
-      def initialize( app )
+      def initialize( app, name )
         @app = app
+        @logger = app.logger
+        @name = name
       end
       
-      # 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 domain
-        self.class.domain
+      # Shortcut method to access other resources
+      def resource( name )
+        @app.resource( name )
       end
       
       # Defines the url type the resource is going to 
@@ -34,6 +32,24 @@ module RubyRest
         @mount_point
       end
       
+      # Sets the list of properties thqt can be updated
+      def self.with_mutable_props *props
+        @mutable_props = *props
+      end
+      
+      # Returns the list of properties thqt can be 
+      # updated
+      def self.mutable_props; @mutable_props end
+      
+      def self.related opts
+        self.related_resources[opts[:property]] =opts[:resource]  
+      end
+      
+      def self.related_resources
+        @related_resources = Hash.new if !@related_resources
+        return @related_resources
+      end  
+      
       def self.atom modifiers
         self.props << modifiers
       end
@@ -56,21 +72,40 @@ module RubyRest
         return @links
       end
       
-      # Updates the specified object with the data found
-      # in the specified xml object, and the rules defined in 
-      # the resource parsers
-      def bind( object, xml )
-        self.class.props.each{ |p| 
-          @app.formatter(p).property( p ).parse( object, p, xml ) 
-        }
-        return object
-      end
-      
       # String representation of a resource
       def to_s
-        "path #{self.class.mount_point}, domain #{self.domain}"
+        "path #{self.class.mount_point}, class #{self.class}"
       end
       
-  end
+    end
     
+    class Sequel < Base
+      
+      attr_reader :dataset
+      
+      # Creates a new resource, under the given application
+      def initialize( app, name )
+        super( app, name )
+        @dataset = app.db[self.class.table_name]
+      end
+      
+      # Provides access to an arbitrary table
+      def table( name )
+        app.db[name]
+      end
+      
+      def self.with_table_name table_name
+        @table_name = table_name
+      end
+
+      def self.table_name
+        @table_name
+      end
+      
+    end
+   
+  end 
+  
+  
+   
 end

data/lib/rubyrest/webrick.rb

@@ -11,7 +11,7 @@ module RubyRest
       # Builds a new Webrick adapter instance
       # for the given application
       def initialize( app )
-        super( :Port => app.config[:http_port] )
+        super( :Port => app.config[:http_port], :Logger => app.logger )
         @app = app
         servlet = RubyRest::Webrick::Servlet.new( self )
         mount "/", servlet
@@ -49,10 +49,11 @@ module RubyRest
         args = Hash.new
         url_tokens = decode_path( request.path ).split( "/")
         args[:authkey] = request["token"]
+        args[:format]= request["format"]
         args[:target] = url_tokens[2] if url_tokens.length>2
         args[:property] = url_tokens[3] if url_tokens.length>3
         args[:path] = request.path
-        args[:body] = RubyRest::Atom::Document.new( request.body ) if request.body
+        args[:body] = @app.parse_request( args, request ) if request.body
         return args
       end
       
@@ -60,27 +61,27 @@ module RubyRest
         params = args(request )
         response.status = 200
         params[:action]=:retrieve
-        xml = @app.retrieve( params )
+        data = @app.retrieve( params )
         response["content-type"]=params[:content_type]
-        xml.write( response.body )  
+        response.body = data  
       end
       
       def do_POST( request, response )
         params = args(request )
         response.status = 201
         params[:action]=:create
-        xml = @app.create( params )
+        data = @app.create( params )
         response["content-type"]=params[:content_type]
-        xml.write( response.body )
+        response.body = data  
       end
       
       def do_PUT( request, response )
         params = args(request )
         response.status = 200
         params[:action]=:update
-        xml = @app.update( params )
+        data = @app.update( params )
         response["content-type"]=params[:content_type]
-        xml.write( response.body )
+        response.body = data  
       end
       
       def do_DELETE( request, response )
@@ -90,6 +91,10 @@ module RubyRest
         @app.delete( params )
       end
       
+      def to_s
+        "Ruby-on-Rest WEBrick servlet"
+      end
+      
     end
   
   end

data/lib/rubyrest/yaml.rb

@@ -0,0 +1,33 @@
+module RubyRest
+  
+  module Format
+    
+    class Yaml
+      
+      def initialize( app )
+        @app = app
+      end
+      
+      def format( model, params )
+        model.to_yaml
+      end
+      
+      def parse_request( request )
+        YAML::load( request )
+      end
+      
+      # Treats the object and the source 
+      # as a hash, and updates the object
+      def bind( object, source, params )
+        # preprocesses the source hash
+        # and updates the domain data
+        resource = params[:resource]
+        resource.process_request_data( source ) if resource.respond_to?( :process_request_data )
+        object.update( source )
+      
+      end
+      
+    end
+    
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: rubyrest
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-06-10 00:00:00 +02:00
+  version: 0.2.0
+date: 2007-08-17 00:00:00 +02:00
 summary: REST framework for Ruby.
 require_paths: 
 - lib
@@ -43,6 +43,7 @@ files:
 - lib/rubyrest/engine.rb
 - lib/rubyrest/resource.rb
 - lib/rubyrest/webrick.rb
+- lib/rubyrest/yaml.rb
 test_files: []
 
 rdoc_options: