rubyrest 0.0.5 → 0.1.0

data/lib/rubyrest/engine.rb

@@ -1,49 +1,45 @@
-# RubyRest: $Id:$
-# 
-# 
-# 
-
 module RubyRest
   
-  # Objects of this class take a configuration as argument
-  # then launch a new server instance. 
+  # The Ruby-on-Rest Engine is the glue between 
+  # the custom application and the webserver implementation
   class Engine
-    include Tools
     
-    # Enables external objects to read the 
-    # engine configuration
-    attr_reader :config
+    # The application
+    attr_reader :app
     
-    # Creates a new RubyRest engine, for the specified
-    # hash of configuration data. The specified hash of params
-    # will be 'interned' so that config keys are accessible
-    # as symbols instead of strings.
-    def initialize( original )
-      params = {}
-      original.each{ |k,v| params[ k.intern ] = v }
-      @service = params[ :service ]
-      @prefix = params[ :prefix ]
-      service_module = to_module_name( @prefix, @service )
-      require @service
-      @config = to_class( service_module, "config" ).new( params )
-      @config[ :servicemodule ] = service_module
+    # Initializes the Ruby-on-Rest Engine, Application and Webserver.
+    # The Application must be installed as a rubygem so that
+    # the statement +require @service+ works.
+    def initialize( config )
+      params = intern_config( config )
+      require params[:service]
+      @app = Class.by_name( params[:module].capitalize + "::" + params[:service].capitalize + "::Application"  ).new( params )
+      if params[:daemon ] != nil
+        @daemon = params[:daemon ] 
+      else @daemon=true end
+      @server = Class.by_name( "RubyRest::" + params[:webserver].to_s.capitalize + "::Server" ).new( @app )
     end
     
-    # Starts the engine. The following operations are accomplished:
-    # 
-    #   1. configure the database
-    #   2. launch the webserver, in daemon mode unless false is 
-    # specified in the configuration
+    
+    # Returns a new hash, with all the keys as symbols
+    def intern_config( hash )
+      interned = Hash.new
+      hash.each{ |k,v| interned[ k.intern ] = v }
+      return interned
+    end
+    
+    # Starts the server, embedded or as a detached
+    # daemon
     def start
-      configure_database if @config.has( :adapter )
-      @server = RubyRest::Server.new( @config )
-      @server.mount "/", CRUDServlet
-      if @config.has( :daemon ) and @config[ :daemon ] == false 
-        start_server 
-      else start_daemon end
+      if @daemon
+        @pid = fork do
+          @server.up
+        end
+        puts "#{self.to_s}: started - pid=#{@pid}, port=#{@app.config[:http_port]}"
+      else @server.up end
     end
     
-    # Shutdowns the current server, if existing.
+    # Shutdowns the current server.
     # This is only useful when working in daemon mode.
     def stop
       return if @pid == nil
@@ -51,56 +47,11 @@ module RubyRest
       puts "#{self.to_s}: killed process with pid=#{@pid}"
     end
     
-    # Configures the database connectivity
-    def configure_database
-      @config.connect_to_database
-      @config.setup_persistence
-      if @config[ :destroy ] == true
-        @config.init_schema
-        @config.load_initial_data
-      end
-    end
-    
-    # Starts the server in another process
-    def start_daemon
-      @pid = fork do
-        start_server
-      end
-      puts "#{self.to_s}: started process with pid=#{@pid}"
-    end
-    
-    # Starts the server
-    def start_server
-      [ "INT", "TERM" ].each { |signal|
-        trap( signal ) { @server.shutdown }
-      }
-      @server.start
-    end
-    
-    # Returns the service name
+    # Returns the deployed application name
     def to_s 
-      "rubyrest: #{@service}"
+      "rubyrest: #{@app}"
     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/resource.rb

@@ -0,0 +1,87 @@
+module RubyRest
+    
+  # Base REST Resource class that acts as a wrapper for the actual
+  # business logic, data formatting (response time) and validations (request time)
+  class Resource
+      
+      # Creates a new resource, under the given application
+      def initialize( app )
+        @app = app
+      end
+      
+      # Convenience method
+      def service
+        self.class.service
+      end
+      
+      # Convenience method
+      def model
+        self.class.model
+      end
+      
+      # Defines the url type the resource is going to 
+      # handle
+      def self.with_mount_point path
+        @mount_point = path
+      end
+      
+      def self.mount_point
+        @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
+      
+      # Returns the list of formatters
+      def self.props
+        @props = [] if !@props
+        return @props
+      end
+      
+      # Declares a new link
+      def self.link modifiers
+        self.links << modifiers
+      end
+      
+      # Returns the array of links declared
+      # for the resource
+      def self.links
+        @links = [] if !@links
+        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}, service #{self.class.service}, model #{self.class.model}"
+      end
+      
+  end
+    
+end

data/lib/rubyrest/webrick.rb

@@ -0,0 +1,92 @@
+module RubyRest
+  
+  module Webrick
+    
+    
+    # The Ruby-on-Rest Webrick adapter implementation
+    class Server < WEBrick::HTTPServer
+    
+      attr_reader :app
+    
+      # Builds a new Webrick adapter instance
+      # for the given application
+      def initialize( app )
+        super( :Port => app.config[:http_port] )
+        @app = app
+        servlet = RubyRest::Webrick::Servlet.new( self )
+        mount "/", servlet
+      end
+    
+      # Starts the server
+      def up
+        [ "INT", "TERM" ].each { |signal|
+          trap( signal ) { shutdown }
+        }
+        start
+      end
+    
+    end
+    
+    # A REST servlet for Webrick adapter
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      
+      # Builds a new servlet, taking the application from it
+      def initialize( server )
+        @app = server.app
+      end
+      
+      # A single servlet instance will be used 
+      # for all requests
+      def get_instance( server )
+        self
+      end
+      
+      def decode_path( path )
+        path.gsub( "+", " ")
+      end
+      
+      def args( request )
+        args = Hash.new
+        url_tokens = decode_path( request.path ).split( "/")
+        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
+        return args
+      end
+      
+      def do_GET( request, response )
+        params = args(request )
+        response.status = 200
+        xml = @app.retrieve( params )
+        response["content-type"]=params[:content_type]
+        xml.write( response.body )  
+      end
+      
+      def do_POST( request, response )
+        params = args(request )
+        response.status = 201
+        xml = @app.create( params )
+        response["content-type"]=params[:content_type]
+        xml.write( response.body )
+      end
+      
+      def do_PUT( request, response )
+        params = args(request )
+        response.status = 200
+        xml = @app.update( params )
+        response["content-type"]=params[:content_type]
+        xml.write( response.body )
+      end
+      
+      def do_DELETE( request, response )
+        params = args(request )
+        response.status = 200
+        @app.delete( params )
+      end
+      
+    end
+  
+  end
+  
+end

data/lib/rubyrest.rb

@@ -3,23 +3,18 @@
 # Entry point to the framework.
 # Loads all the files under the 'rubyrest' subdirectory
 require "rubygems"
+require "sequel"
+require "sequel/postgres"
 require "extensions/all"
-require "builder"
 require "rexml/document"
 require "webrick"
+require "find"
 
-
-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" )
+here = File.dirname( __FILE__ )
+dir = File.join( here , 'rubyrest' )
+require File.join( dir, "webrick" )
+require File.join( dir, "resource" )
+require File.join( dir, "application" )
 require File.join( dir, "engine" )
-require File.join( dir, "client" )
-
-module RubyRest #:nodoc:
-  class << self
-    
-  end
-end
+require File.join( dir, "atom" )
+require File.join( dir, "client" )

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: rubyrest
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
-date: 2007-04-20 00:00:00 +02:00
+  version: 0.1.0
+date: 2007-06-04 00:00:00 +02:00
 summary: REST framework for Ruby.
 require_paths: 
 - lib
@@ -37,13 +37,12 @@ files:
 - doc/rdoc
 - lib/rubyrest
 - lib/rubyrest.rb
+- lib/rubyrest/application.rb
 - lib/rubyrest/atom.rb
 - lib/rubyrest/client.rb
-- lib/rubyrest/config.rb
 - lib/rubyrest/engine.rb
-- lib/rubyrest/servlets.rb
-- lib/rubyrest/tools.rb
-- examples/hello.rb
+- lib/rubyrest/resource.rb
+- lib/rubyrest/webrick.rb
 test_files: []
 
 rdoc_options: 
@@ -58,13 +57,10 @@ rdoc_options:
 - --inline-source
 - --exclude
 - lib/rubyrest.rb
-- --include
-- examples/*.rb
 extra_rdoc_files: 
 - README
 - CHANGELOG
 - COPYING
-- examples/hello.rb
 executables: 
 - rubyrest
 extensions: []

data/examples/hello.rb

@@ -1,57 +0,0 @@
-# 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 
-      
-    end
-    
-    # The dashboard that provides an entry point to the 
-    # application
-    class Dashboard
-      
-      def self.rest_retrieve( principal )
-        [ "welcomeservice" ]
-      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/config.rb

@@ -1,80 +0,0 @@
-# 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
-  #       
-  #     end
-  #   end
-  #
-  #
-  class SimpleConfig
-     include RubyRest::Tools
-     
-     # Initializes a new configuration with the specified
-     # hash of data
-     def initialize( hash )
-       @hash = hash
-     end
-     
-     # 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 "key: #{k}, value: #{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 = "#{self[:adapter]}_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