rubyrest 0.0.1

data/CHANGELOG

@@ -0,0 +1,6 @@
+*0.0.1*
+
+* Initial release with very basic CRUD facilities
+* Hello sample application included
+  
+

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2007 Pedro Gutierrez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,44 @@
+== Ruby-on-Rest: Simple REST Framework for Ruby
+
+Ruby-on-Rest (rubyrest) provides a simple framework to help you expose
+your business objects as web resources. 
+
+Ruby-on-Rest provides an programming model and a security framework that 
+lets you create new REST services without too much effort. 
+
+== Resources
+
+* {Project Documentation}[http://rubyrest.rubyforge.org]
+* {Project Page at Rubyforge}[http://rubyforge.org/projects/rubyrest]
+* {Project Page at Google Code}[http://code.google.com/p/rubyrest]
+
+To check out the source code:
+  
+  svn checkout http://rubyrest.rubyforge.org/svn/trunk
+  
+=== Contact
+
+If you have any comments or suggestions please send an email to pedro dot gutierrez at netcourrier dot com and I'll get back to you.
+
+== Installation
+
+  sudo gem install rubyrest
+  
+== Getting Started
+
+=== Learning by example
+
+Please have a look at the examples provided, they are simple enough to let you grasp how rubyrest works.
+
+=== Starting and stopping the service
+
+Ruby-on-Rest provides a shell command. Open your console, and type the following:
+ 
+  rubyrest start|stop <my_service> [<my_service_module>]
+
+=== Configuring your service
+
+Ruby-on-Rest will try to load a file name <my_service>.rb which must provide access to
+the service configuration, service and model.
+
+

data/Rakefile

@@ -0,0 +1,106 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+include FileUtils
+
+NAME = "rubyrest"
+VERS = "0.0.1"
+CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
+RDOC_OPTS = ['--quiet', '--title', "Ruby-on-Rest: A simple REST framework for Ruby",
+  "--opname", "index.html",
+  "--line-numbers", 
+  "--main", "README",
+  "--inline-source"]
+
+desc "Packages up Ruby-on-Rest."
+task :default => [:package]
+task :package => [:clean]
+
+task :doc => [:rdoc]
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.options += RDOC_OPTS
+  rdoc.main = "README"
+  rdoc.title = "Ruby-on-Rest Documentation"
+  rdoc.rdoc_files.add ['README', 'COPYING', 'lib/rubyrest.rb', 'lib/rubyrest/**/*.rb', 'examples/**/*.rb' ]
+end
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VERS
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING", 'examples/hello.rb' ]
+  s.rdoc_options += RDOC_OPTS + [ '--exclude', 'lib/rubyrest.rb', '--include', 'examples/*.rb' ]
+  s.summary = "REST framework for Ruby."
+  s.description = s.summary
+  s.author = "Pedro Gutierrez"
+  s.email = 'pedro.gutierrrez@netcourrier.com'
+  s.homepage = 'http://rubyrest.rubyforge.org'
+  s.executables = ['rubyrest']
+
+  s.add_dependency('metaid')
+  s.required_ruby_version = '>= 1.8.2'
+
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,lib}/**/*")
+      
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS}}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end
+
+desc 'Update docs and upload to rubyforge.org'
+task :doc_rforge do
+  sh %{rake doc}
+  sh %{scp -r doc/rdoc/* sicozu@rubyforge.org:/var/www/gforge-projects/rubyrest}
+end
+
+
+desc 'Make a release in Rubyforge'
+task :release => [:clean, :package, :doc_rforge ] do
+  # create a svn tag
+  sh %{svn copy svn+ssh://rubyforge.org/var/svn/rubyrest/trunk svn+ssh://rubyforge.org/var/svn/rubyrest/tags/#{VERS}}
+  # upload the gem
+  sh %{scp pkg/#{NAME}-#{VERS}.gem sicozu@rubyforge.org:/var/www/gforge-projects/rubyrest/}
+end
+
+require 'spec/rake/spectask'
+
+desc "Run specs with coverage"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.rcov = true
+end
+
+##############################################################################
+# Statistics
+##############################################################################
+
+STATS_DIRECTORIES = [
+  %w(Code   lib/),
+  %w(Spec   spec/)
+].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'extra/stats'
+  verbose = true
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end
+

data/bin/rubyrest

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+# RubyRest $Id:$
+# 
+# UNIX Command Line.
+require 'rubygems'
+require 'rubyrest'
+
+
+module RubyRest
+  
+  
+  class RubyRestBoot
+    include RubyRest::Tools
+    
+    def initialize( option, service, prefix = nil )
+      
+      if option == nil or service == nil or !self.respond_to?( option )  
+        help_and_exit
+        return
+      end
+      
+      @option = option
+      @service = service
+      @service_prefix = prefix
+      
+      #begin
+        self.method( @option ).call 
+      #rescue => e
+      #  puts "ERROR #{e.message}"
+      #end
+      
+    end
+    
+    def help_and_exit
+      puts "Usage: rubyrest start|stop <your_service> "
+      puts "Ruby-on-Rest: Simple REST for Ruby."
+      puts
+      puts "Examples:"
+      puts "  rubyrest start grape"
+      puts "  rubyrest stop grape"
+      puts
+      puts "For more information see http://rubyrest.rubyforge.org"
+    end
+    
+    def start
+      service_module = to_module_name( @service_prefix, @service )
+      require @service
+      puts "=> Starting service '#{@service}' in module '#{service_module}'"
+      config = to_class( service_module, "config" ).new
+      config[ :servicemodule ] = service_module
+      RubyRest::Engine.new( config ).start
+      puts "=> Service #{@service} running!"
+    end
+    
+    
+    def stop
+      puts "=> Stopping service #{@service}..."
+      
+      
+      puts "=> Service #{@service} stopped!"
+    end
+    
+  end
+end
+
+RubyRest::RubyRestBoot.new( ARGV[0], ARGV[1], ARGV[2] )

data/examples/hello.rb

@@ -0,0 +1,57 @@
+# Ruby-on-Rest HelloWorld application
+# 
+#
+#
+module Acme
+  
+  module Hello
+    
+    # The configuration for the Acme::Hello service.
+    # This is a simple service that does not need database
+    # connectivity.
+    class Config < RubyRest::SimpleConfig 
+      
+      # Inits the internal hash of 
+      # configuration options. This is the minimal expression
+      # of a Ruby-on-Rest configuration hash.
+      def initialize
+        @hash = { 
+          :servicemodel => [ "welcomeservice" ],
+          :serviceport => 9001
+        }
+      end
+    
+    end
+    
+    # The domain service that actually implements 
+    # 'business' logic. In this case, it's just going to say "Hello!"
+    # by returning a HelloBean object
+    class Welcomeservice
+      
+      # Returns a simple object that says hello
+      # This is the method invoked by RubyRest::CRUDServlet 
+      # when it receives a GET request with no particular resource id
+      def self.rest_retrieve( principal ) 
+        HelloBean.new
+      end
+      
+    end
+    
+    # The object that encapsulates the so sophisticated
+    # message. By including RubyRest::Atom::Entry, we get some convenience
+    # methods that help to provide an atom entry representation
+    # of the bean, without too much effort. 
+    class HelloBean
+      include RubyRest::Atom::DummyEntry
+      
+      # The hello message, included as a 'message' 
+      # node inside an Atom Entry content. 
+      def atom_content( builder )
+        builder.message "Hello!"
+      end
+    end
+    
+  end
+  
+end
+  

data/lib/rubyrest/atom.rb

@@ -0,0 +1,204 @@
+# Simple ATOM Feed Generator, used by REST
+# Servlets as the representation of resources returned
+# to the client.
+# 
+#
+# $Id:$
+module RubyRest
+  
+  module Atom
+    include RubyRest::Tools
+      
+      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"
+            build_feed( @result, builder, request.request_uri, request.path, @method )
+          else build_entry( @result, builder, request.request_uri ) end
+        end
+      end
+  
+  
+      # Builds an Atom Service Document. This is a representation of the 
+      # user's dashboard or initial workspace.
+      def build_service_document( workspace, builder, uri )
+        builder.service( NAMESPACES ){
+          builder.workspace {
+            builder.title "Dashboard"
+            workspace.each { |w| 
+              builder.collection( { "href" =>  "#{uri}#{w}" } ) {
+                builder.title "#{w}_all"
+                builder.accept "entry"
+              }
+            }
+          }
+        }
+      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
+            object.atom_related.each{ |related| 
+                builder.link( "rel" => "related", "href" => "#{entry_link}/#{related}", "title" => "#{related}", "type" =>  ATOM_TYPE ) 
+            }
+          end
+      
+          builder.moodisland :content do
+            object.atom_content( builder ) if object.respond_to? :atom_content
+          end
+        }
+    
+      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
+
+        # Returns the generated token
+        def atom_id
+          self.id
+        end
+
+        # Returns Time.now
+        def atom_updated
+          self.updated
+        end
+
+        # Not a very relevant buy necessary information
+        def atom_author
+          self.createdby
+        end
+
+      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
+
+      end
+      
+      # Very simple module that adds some binding facilities
+      #
+      module EntryBinder 
+        
+        # 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
+
+      end
+    
+  end
+end

data/lib/rubyrest/config.rb

@@ -0,0 +1,78 @@
+# RubyRest: $Id:$
+# 
+# 
+# 
+module RubyRest
+  
+  # This class is meant to be subclassed with customized
+  # behaviour that will be invoked by the engine at startup.
+  # Subclasses can provide connectivity to popular database
+  # frameworks such as ActiveRecord, Sequel or Og.
+  # 
+  # Example:
+  #
+  #   module MyService
+  #     class Config < RubyRest::SimpleConfig
+  #       def initialize
+  #         @hash = { 
+  #            ... my config here ..
+  #         }
+  #       end
+  #     end
+  #   end
+  #
+  #
+  class SimpleConfig
+     include RubyRest::Tools
+     
+     # Overrides the specified configuration option
+     # with its new value
+     def []=( name, value )
+       @hash[ name ] = value
+     end
+
+     # Returns a given configuration option value
+     def [](name)
+       raise error( 000, name ) if !has( name )
+       return @hash[ name ]
+     end
+     
+     # Returns true if the specified name matches
+     # a valid configuration option
+     def has( name )
+       @hash[ name ] != nil
+     end  
+
+     # Dumps all the configuration options
+     def to_s
+       @hash.each{ |k,v| puts "#{k} = #{v}" }
+     end
+     
+  end
+  
+  # Specialization of SimpleConfig that provides 
+  # hooks for database initialization during startup
+  class DatabaseConfig < SimpleConfig
+    
+    # Connects and returns a database instance.
+    #
+    # This method
+    # will delegate to a more specialized method, according to the
+    # :adapter config option
+    def connect_to_database
+      adapter_method = "#{@hash[:dbadapter]}_connect"
+      error( 004, self, adapter_method ) if !self.respond_to?( adapter_method )
+      @db = self.method( adapter_method ).call
+      error( 005, self, adapter_method ) if @db == nil
+    end
+    
+    # This method must be implemented in subclasses
+    # Intentionnaly left empty
+    def init_database
+      
+    end
+     
+  end
+  
+  
+end

data/lib/rubyrest/engine.rb

@@ -0,0 +1,77 @@
+# RubyRest: $Id:$
+# 
+# 
+# 
+
+module RubyRest
+  
+  # Objects of this class take a configuration as argument
+  # then launch a new server instance. 
+  class Engine
+    
+    # Enables external objects to read the 
+    # engine configuration
+    attr_reader :config
+    
+    # Creates a new RubyRest engine, for the specified
+    # configuration
+    def initialize( config )
+      @config = config
+    end
+    
+    # Starts the engine. 
+    # The following operations are accomplished:
+    # 
+    #   1. establish a connection to the database
+    #   2. initialize the database schema
+    #   3. load initial data into the database
+    #
+    def start
+      configure_database if @config.has( :dbadapter )
+      start_server
+    end
+    
+    # Configures the database connectivity
+    def configure_database
+      @config.connect_to_database
+      @config.setup_persistence
+      if @config[ :dbdestroy ] == true
+        @config.init_schema
+        @config.load_initial_data
+      end
+    end
+    
+    # Configures and returns a new web server
+    # instance. For the moment, only WEBrick instances
+    # are supported 
+    def start_server
+      server = RubyRest::Server.new( @config )
+      [ "INT", "TERM" ].each { |signal|
+        trap( signal ) { server.shutdown }
+      }
+      server.mount "/", CRUDServlet
+      server.start
+    end
+    
+  end
+  
+  
+  # Adds some extra functionnality to the actual server
+  # implementation.
+  #
+  class Server < WEBrick::HTTPServer
+    
+    # the configuration options
+    attr_accessor :rubyrest
+    
+    # Creates a new WEBrick instance with the specified
+    # configuration
+    def initialize( config )
+      super( :Port => config[ :serviceport ] )
+      @rubyrest = config
+    end
+  
+  end
+  
+  
+end

data/lib/rubyrest/servlets.rb

@@ -0,0 +1,235 @@
+# WEBrick servlet that implements a simple mapping between
+# HTTP methods and request paths into business methods, using some
+# conventions. 
+# 
+# Developpers should only subclass this servlet, and implement 
+# standard methods that return a xml content.
+# 
+# $Id:$
+module RubyRest
+  
+  # This is the servlet that actually exposes a REST API
+  # by translating HTTP requests into 'generic' or 'custom' service
+  # methods.
+  # 
+  class RESTServlet < WEBrick::HTTPServlet::AbstractServlet
+    include RubyRest::Atom, RubyRest::Tools
+    
+    # Injects some RubyRest configuration options
+    # from the server to the servlet
+    def initialize( server, *options )
+      super( server, options )
+      @servicemodule = server.rubyrest[ :servicemodule ]
+      
+      if server.rubyrest.has( :authmodel )
+        @authmodel = server.rubyrest[ :authmodel ]
+      end
+      
+      if server.rubyrest.has( :dashboard )
+        @dashboard = server.rubyrest[ :dashboard ]
+      else @dashboard = server.rubyrest[ :servicemodel ][0] end
+        
+    end
+    
+    # Inspects the request, and resolve the parameters
+    # The format of a request is the following:
+    #     
+    # /:model/:id/:property
+    # 
+    def resolve_params( request )
+      params = request.path.split( "/" )
+      @http_method = request.request_method
+      @token = request[ 'token']
+      @model = params[1]
+      @id = params[2]
+      @property = params[3]
+      @body = REXML::Document.new( request.body ) if request.body != nil
+    end
+  
+    def resolve_custom_method
+      if @property != nil
+        @custom_method = "#{@model}_#{@property}"
+      else 
+        @custom_method = WORKSPACE_METHOD
+        @custom_method = "#{@model}_#{@generic_method}" if @model != nil
+      end
+    end
+  
+    def resolve_service_method
+      resolve_custom_method
+      return @custom_method if self.respond_to? @custom_method
+      return @generic_method
+    end
+  
+    def dispatch( request, response )
+    
+      @service_method = resolve_service_method
+      check_security( request ) if @authmodel != nil
+      @result = self.method( @service_method ).call( request )
+    
+      if @result.respond_to? "unauthorized" and @result.unauthorized == true
+        raise WEBrick::HTTPStatus::Unauthorized
+      else
+        response.status = @success_code
+        format_response( request, response ) if @result != nil
+        raise WEBrick::HTTPStatus::OK
+      end
+    end
+    
+    
+    def resolve_get_method
+      if @property != nil
+          @generic_method = :retrieve_related
+      else 
+        if @id != nil 
+          @generic_method = :show
+        else @generic_method = :retrieve end 
+      end
+    end
+  
+    def do_GET( request, response )
+      resolve_params( request )
+      @success_code = 200
+      resolve_get_method
+      dispatch( request, response )
+    end
+  
+    def do_POST( request, response )
+      resolve_params( request )
+      incompatible_path( request ) if @id != nil
+      @generic_method = :create
+      @success_code = 201
+      dispatch( request, response )
+    end
+  
+    def do_PUT( request, response )
+      resolve_params( request )
+      incompatible_path( request ) if @id == nil
+      @generic_method = :update
+      @success_code = 200
+      dispatch( request, response )
+    end
+  
+    def do_DELETE( request, response )
+      resolve_params( request )
+      incompatible_path( request ) if @id == nil
+      @generic_method = :delete
+      @success_code = 200
+      dispatch( request, response )
+    end
+    
+    # Raises an error stating that the current
+    # http method is not compatible with the requested path.
+    def incompatible_path( request )
+      error( 100, @http_method, request.path )
+    end
+    
+    # Custom service method that authenticates a username/password pair 
+    # found in the request body. The authentication is left to the class defined by the
+    # :authmodel configuration option. 
+    #
+    # Developpers can provide their own implementation, however it is recommended to 
+    # subclass the class *Credentials*
+    def credentials_create( request )
+      auth_class = to_class( @servicemodule, @authmodel )
+      auth = auth_class.new
+      auth_class.rest_bind( auth, @body )
+      auth = auth_class.authenticate( auth )
+      raise WEBrick::HTTPStatus::Unauthorized if auth == nil
+      return auth  
+    end
+    
+    ANONYMOUS_ACCESS = "POST/credentials"
+    
+    # Defines whether the request is allowed to be processed
+    # without the need of a security token 
+    # 
+    def anonymous_access
+      "#{@http_method}/#{@model}" == ANONYMOUS_ACCESS
+    end
+    
+    # Checks that a token is present in the request
+    # exception if doing a POST on a credentials property
+    def check_security( request )
+      auth_class = to_class( @servicemodule , @authmodel )
+      if @token == nil and !anonymous_access
+        raise WEBrick::HTTPStatus::Unauthorized
+      end
+      if @token != nil
+        @principal = auth_class.validate( @token )
+        raise WEBrick::HTTPStatus::Unauthorized if @principal == nil
+      end
+    end
+    
+    # Returns the model defined by the configuration
+    # option :dashboard
+    #
+    def dashboard( request ) 
+      [ @dashboard ]
+    end
+  
+  end
+  
+  
+  
+  # Generic servlet, that implements the Moodisland Grape API
+  # This layer returns domain objects that can be included
+  # in atom feeds as entries.
+  # 
+  class CRUDServlet < RESTServlet 
+
+    # Creates and saves a new object. The object is then
+    # returned
+    def create( request )
+      clazz = to_class( @servicemodule, @model )
+      object = clazz.rest_create( @principal )
+      clazz.rest_bind( object, @body )
+      clazz.rest_save( object, @principal )
+    end
+
+    # Retrieves a list of objects
+    #
+    def retrieve( request )
+      clazz = to_class( @servicemodule, @model )
+      clazz.rest_retrieve( @principal )
+    end
+    
+    # Retrieve a list of related objects
+    #
+    def retrieve_related( request )
+      clazz = to_class( @servicemodule, @model )
+      service_method = "rest_#{@property}"
+      error( 500, clazz.name, service_method ) if !clazz.respond_to?( service_method )
+      clazz.method( service_method ).call( @id, @principal )
+    end
+    
+    # Retrieves a single object
+    #
+    def show( request )
+      clazz = to_class( @servicemodule, @model )
+      single = clazz.rest_single( @id, @principal )
+      raise error( 200, @model, @id ) if single == nil
+      return single
+    end
+
+    # Deletes a single object
+    #
+    def delete( request )
+      clazz = to_class( @servicemodule, @model )
+      clazz.rest_delete( @id, @principal )
+    end
+    
+    # Retrieves, updates and saves an existing object.
+    # The object is then returned
+    #
+    def update( request )
+      object = show( request )
+      clazz = object.class
+      clazz.rest_bind( object, @body )
+      clazz.rest_save( object, @principal )
+    end
+    
+  end
+
+
+end

data/lib/rubyrest/tools.rb

@@ -0,0 +1,72 @@
+# RubyRest: $Id:$
+# 
+# 
+#
+
+module RubyRest 
+  
+  # This module provides a catalog of errors
+  # the application is supposed to throw.
+  # 
+  #
+  module Tools
+    
+    
+    ATOM_DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+    
+    def nvl( value, default )
+      return value if value != nil
+      return default
+    end
+
+    def format_atom_date( value )
+      nvl( value, Time.now ).strftime( ATOM_DATE_FORMAT )
+    end
+
+    def parse_atom_date( value )
+      Date.strptime( value, ATOM_DATE_FORMAT )
+    end
+
+    # Resolves the specified module name and model
+    # into a class, and returns it
+    def to_class( modulename, model )
+      Class.by_name( "#{modulename}::#{model.capitalize}" )
+    end
+    
+    # Builds a gem name 
+    def to_gem_name( moduleprefix, modulename )
+      return modulename if moduleprefix == nil
+      return "#{moduleprefix}-#{modulename}"
+    end
+    
+    # Builds a fully qualified module name
+    def to_module_name( moduleprefix, modulename )
+      return modulename.capitalize if moduleprefix == nil
+      return "#{moduleprefix.capitalize}::#{modulename.capitalize}"
+    end
+    
+    # Catalog of error messages, indexed by error
+    # number
+    ERRORS = {
+      000 => "Missing configuration option",
+      001 => "Unable to connect to database. Missing method",
+      002 => "Unable to load schema. Missing method",
+      003 => "Unable to create table",
+      004 => "Please subclass and override",
+      005 => "Sorry, configuration method did not return a valid database connection",
+      006 => "Class was not property configured with its database connection (Sequel)",
+      100 => "Request path and HTTP method are not compatible",
+      200 => "No resource found for model and id",
+      500 => "No service method found in model class"
+    }
+    
+    # Raises a new error. Resolves the specified
+    # number into a human readable message
+    def error( number, *params )
+      raise "\##{number}: #{ERRORS[number]}: #{params.join( ', ') }"
+    end
+    
+    
+  end
+  
+end

data/lib/rubyrest.rb

@@ -0,0 +1,24 @@
+# RubyRest: $Id:$
+# 
+# Entry point to the framework.
+# Loads all the files under the 'rubyrest' subdirectory
+require "rubygems"
+require "extensions/all"
+require "builder"
+require "rexml/document"
+require "webrick"
+require "atom"
+
+dir = File.join( File.dirname( __FILE__ ), 'rubyrest' )
+
+require File.join( dir, "tools" )
+require File.join( dir, "atom" )
+require File.join( dir, "servlets" )
+require File.join( dir, "config" )
+require File.join( dir, "engine" )
+
+module RubyRest #:nodoc:
+  class << self
+    
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.1
+specification_version: 1
+name: rubyrest
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-03-28 00:00:00 +02:00
+summary: REST framework for Ruby.
+require_paths: 
+- lib
+email: pedro.gutierrrez@netcourrier.com
+homepage: http://rubyrest.rubyforge.org
+rubyforge_project: 
+description: REST framework for Ruby.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Pedro Gutierrez
+files: 
+- COPYING
+- README
+- Rakefile
+- bin/rubyrest
+- doc/rdoc
+- lib/rubyrest
+- lib/rubyrest.rb
+- lib/rubyrest/atom.rb
+- lib/rubyrest/config.rb
+- lib/rubyrest/engine.rb
+- lib/rubyrest/servlets.rb
+- lib/rubyrest/tools.rb
+- CHANGELOG
+- examples/hello.rb
+test_files: []
+
+rdoc_options: 
+- --quiet
+- --title
+- "Ruby-on-Rest: A simple REST framework for Ruby"
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- lib/rubyrest.rb
+- --include
+- examples/*.rb
+extra_rdoc_files: 
+- README
+- CHANGELOG
+- COPYING
+- examples/hello.rb
+executables: 
+- rubyrest
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: