rubyrest 0.0.5 → 0.1.0

data/lib/rubyrest/servlets.rb

@@ -1,233 +0,0 @@
-# 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
-    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]
-      begin
-        @body = REXML::Document.new( request.body ) if request.body != nil
-      rescue => e
-        puts "unable to parse request body: #{request.body}"
-      end
-    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 )
-      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 = 410
-      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 ) 
-      clazz = to_class( @servicemodule, "dashboard" )
-      clazz.rest_retrieve( @principal )
-    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

@@ -1,72 +0,0 @@
-# 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