restrack 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specifying gem's dependencies in restrack.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,71 @@
+= RESTRack
+
+== Description:
+  RESTRack is an Rack-based MVC framework tailored specifically to RESTful data
+  services.
+
+== Installation:
+  <sudo> gem install restrack
+
+
+== Why RESTRack when there is Rails?
+
+    
+
+== Usage:
+  - restrack generate service foo_bar
+  - restrack generate controller baz
+  - restrack server 3456
+
+
+== REST action method names
+  All default RESTful controller method names align with their Rails
+  counterparts, with more actions supported.
+
+=== RESTRack:
+    #                    HTTP Verb: |   GET   |   PUT    |   POST   |   DELETE
+    #   Collection URI (/widgets/): |  index  |  replace |  create  |  drop
+    #   Element URI (/widgets/42):  |  show   |  update  |  add     |  destroy
+
+=== Rails
+    #                    HTTP Verb: |   GET   |   PUT    |   POST   |   DELETE
+    #   Collection URI (/widgets/): |  index  |          |  create  |   
+    #   Element URI (/widgets/42):  |  show   |  update  |          |  destroy
+
+
+== How-Tos
+  === Authentication
+  
+  === Logging Level
+  
+  === XML Serialization
+    ==== With Builder
+    ==== With XmlSimple
+          @output = XmlSimple.xml_out(data, 'AttrPrefix' => true)
+  === Inputs
+    ==== GET params
+    ==== POST data
+
+
+
+== License:
+
+Copyright (c) 2010 Chris St. John
+
+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 OR COPYRIGHT HOLDERS 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/Rakefile

@@ -0,0 +1,32 @@
+require 'rake'
+require 'rake/testtask'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => [:test_all]
+
+desc 'Run all tests.'
+Rake::TestTask.new('test_all') { |t|
+  t.pattern = 'test/**/test_*.rb'
+}
+
+desc 'Run sample_app_1 tests.'
+Rake::TestTask.new('test1') { |t|
+  t.pattern = 'test/sample_app_1/**/test_*.rb'
+}
+
+desc 'Run sample_app_2 tests.'
+Rake::TestTask.new('test2') { |t|
+  t.pattern = 'test/sample_app_2/**/test_*.rb'
+}
+
+desc 'Run sample_app_3 tests.'
+Rake::TestTask.new('test3') { |t|
+  t.pattern = 'test/sample_app_3/**/test_*.rb'
+}
+
+desc 'Run sample_app_4 tests.'
+Rake::TestTask.new('test4') { |t|
+  t.pattern = 'test/sample_app_4/**/test_*.rb'
+}

data/bin/restrack

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'restrack'
+
+verb = ARGV[0]
+noun = ARGV[1]
+
+case verb.to_sym
+when :generate
+  name = ARGV[2]
+  case noun.to_sym
+  when :service
+    puts "Generating new RESTRack service #{name}..."
+    RESTRack::Generator.generate_service( name )
+  when :controller
+    puts "Generating new controller #{name}..."
+    RESTRack::Generator.generate_controller( name )
+  end
+  puts 'Creation is complete.'
+when :server
+  options = { :Port => noun || 9292, :config => 'config.ru' }
+  Rack::Server.start( options )
+end

data/config/constants.yaml

@@ -0,0 +1,8 @@
+:LOG:                     '/var/log/restrack/restrack.log'
+:REQUEST_LOG:             '/var/log/restrack/restrack.request.log'
+:LOG_LEVEL:               DEBUG     # Logger object level
+:REQUEST_LOG_LEVEL:       DEBUG     # Logger object level
+:DEFAULT_FORMAT:          :JSON                     # Supported formats are :JSON, :XML, :YAML, :BIN, :TEXT
+:DEFAULT_RESOURCE:        ''                        # The resource which will handle root level requests where the name is not specified.  Best for users of this not to implement method_missing in their default controller, unless they are checking for bad URI. :DEFAULT_RESOURCE should be a member of :ROOT_RESOURCE_ACCEPT.
+:ROOT_RESOURCE_ACCEPT:    []                        # These are the resources which can be accessed from the root of your web service. If left empty, all resources are available at the root.
+:ROOT_RESOURCE_DENY:      []                        # These are the resources which cannot be accessed from the root of your web service. Use either this or ROOT_RESOURCE_ACCEPT as a blacklist or whitelist to establish routing (relationships defined in resource controllers define further routing).

data/lib/restrack/generator/constants.yaml.erb

@@ -0,0 +1,24 @@
+#GENERATOR-CONST# -DO NOT REMOVE OR CHANGE THIS LINE- Application-Namespace => <%= @service_name %>
+#
+# = constants.yaml
+# This is where RESTRack applications define the constants relevant to their particular
+# application that are used by the RESTRack base classes.
+
+# Application log path definition
+:LOG:                     '/var/log/<%= @service_name %>/<%= @service_name %>.log'
+# Request log path definition
+:REQUEST_LOG:             '/var/log/<%= @service_name %>/<%= @service_name %>.request.log'
+
+# Logger object levels
+:LOG_LEVEL:               :DEBUG
+:REQUEST_LOG_LEVEL:       :DEBUG
+
+# Supported formats are :JSON, :XML, :YAML, :BIN, :TEXT
+:DEFAULT_FORMAT:          :JSON
+# The resource which will handle root level requests where the name is not specified.  Best for users of this not to implement method_missing in their default controller, unless they are checking for bad URI.
+:DEFAULT_RESOURCE:        nil
+
+# These are the resources which can be accessed from the root of your web service. If left empty, all resources are available at the root.
+:ROOT_RESOURCE_ACCEPT:    []
+# These are the resources which cannot be accessed from the root of your web service. Use either this or ROOT_RESOURCE_ACCEPT as a blacklist or whitelist to establish routing (relationships defined in resource controllers define further routing).
+:ROOT_RESOURCE_DENY:      []

data/lib/restrack/generator/controller.rb.erb

@@ -0,0 +1,35 @@
+class <%= @service_name.camelize %>::<%= @name.camelize %>Controller < RESTRack::ResourceController
+
+  def index
+
+  end
+  
+  def create
+
+  end
+
+  def replace
+
+  end
+
+  def destroy
+
+  end
+
+  def show(id)
+
+  end
+
+  def update(id)
+
+  end
+
+  def delete(id)
+
+  end
+
+  def add(id)
+
+  end
+
+end

data/lib/restrack/generator/loader.rb.erb

@@ -0,0 +1,21 @@
+require 'restrack'
+
+module <%= @service_name.camelize %>; end
+class <%= @service_name.camelize %>::WebService < RESTRack::WebService; end
+
+RESTRack::CONFIG = RESTRack::load_config(File.join(File.dirname(__FILE__), 'config/constants.yaml'))
+RESTRack::CONFIG[:ROOT] = File.dirname(__FILE__)
+
+# Dynamically load all controllers
+Find.find(  File.join(File.dirname(__FILE__), 'controllers') ) do |file|
+  next if File.extname(file) != '.rb'
+  require file
+end
+
+if File.directory?( File.join(File.dirname(__FILE__), 'models') )
+  # Dynamically load all models
+  Find.find(  File.join(File.dirname(__FILE__), 'models') ) do |file|
+    next if File.extname(file) != '.rb'
+    require file
+  end
+end

data/lib/restrack/generator.rb

@@ -0,0 +1,93 @@
+require 'erb'
+require 'fileutils'
+require 'rubygems'
+require 'active_support/inflector'
+
+module RESTRack
+  class Generator
+    TEMPLATE = {
+      :service    => 'loader.rb.erb',
+      :constants  => 'constants.yaml.erb',
+      :controller => 'controller.rb.erb'
+    }
+    
+    class << self
+      
+      def generate_controller(name)
+        # Generate controller file
+        template = get_template_for( :controller )
+        resultant_string = template.result( get_binding_for_controller( name ) )
+        File.open("#{base_dir}/controllers/#{name}_controller.rb", 'w') {|f| f.puts resultant_string }
+        # Generate view folder for controller
+        FileUtils.makedirs("#{name}/views")
+      end
+  
+      def generate_service(name)
+        FileUtils.makedirs("#{name}/config")
+        FileUtils.makedirs("#{name}/controllers")
+        FileUtils.makedirs("#{name}/models")
+        FileUtils.makedirs("#{name}/test")
+        FileUtils.makedirs("#{name}/views")
+        
+        template = get_template_for( :service )
+        resultant_string = template.result( get_binding_for_service( name ) )
+        File.open("#{name}/loader.rb", 'w') {|f| f.puts resultant_string }
+        
+        template = get_template_for( :constants )
+        resultant_string = template.result( get_binding_for_service( name ) )
+        File.open("#{name}/config/constants.yaml", 'w') {|f| f.puts resultant_string }
+      end
+  
+      private
+  
+      def get_template_for(type)
+        template_file = File.new(File.join(File.dirname(__FILE__),"generator/#{TEMPLATE[type]}"))
+        template = ERB.new( template_file.read, nil, "%" )
+      end
+  
+      def get_binding_for_controller(name)
+        @name = name
+        @service_name = get_service_name
+        binding
+      end
+  
+      def get_binding_for_service(name)
+        @service_name = name
+        binding
+      end
+  
+      def get_service_name
+        line = ''
+        begin
+          File.open(File.join(base_dir, 'config/constants.yaml')) { |f| line = f.gets }
+        rescue
+          raise File.join(base_dir, 'config/constants.yaml') + ' not found or could not be opened!'
+        end
+        begin
+          check = line.match(/#GENERATOR-CONST#.*Application-Namespace\s*=>\s*(.+)/)[0]
+          service_name = $1
+        rescue
+          raise '#GENERATOR-CONST# line has been removed or modified in config/constants.yaml.'
+        end
+        return service_name
+      end
+  
+      def base_dir
+        base_dir = nil
+        this_path = File.join( Dir.pwd, 'config/constants.yaml')
+        while this_path != '/config/constants.yaml'
+          if File.exists?( this_path )
+            base_dir = Dir.pwd
+            break
+          else
+            this_path = File.join('..', this_path)
+          end
+        end
+        raise 'The config/constants.yaml file could not found when determining base_dir!' unless base_dir
+        return base_dir
+      end
+    
+    end # class << self
+
+  end # class
+end # module

data/lib/restrack/http_status.rb

@@ -0,0 +1,10 @@
+module HTTPStatus
+  class HTTP400BadRequest       < Exception; end
+  class HTTP401Unauthorized     < Exception; end
+  class HTTP403Forbidden        < Exception; end
+  class HTTP404ResourceNotFound < Exception; end
+  class HTTP405MethodNotAllowed < Exception; end
+  class HTTP409Conflict         < Exception; end
+  class HTTP410Gone             < Exception; end
+  class HTTP500ServerError      < Exception; end
+end

data/lib/restrack/resource_controller.rb

@@ -0,0 +1,192 @@
+module RESTRack
+  class ResourceController
+    attr_reader :input, :output
+
+    def self.__init(resource_request)
+      # Base initialization method for resources and storage of request input
+      # This method should not be overriden in decendent classes.
+      __self = self.new
+      return __self.__init(resource_request)
+    end
+    def __init(resource_request)
+      @resource_request = resource_request
+      setup_action
+      self
+    end
+
+    def call
+      # Call the controller's action and return it in the proper format.
+      args = []
+      args << @resource_request.id unless @resource_request.id.blank?
+      package( self.send(@resource_request.action.to_sym, *args) )
+    end
+
+    #                    HTTP Verb: |    GET    |   PUT     |   POST    |   DELETE
+    # Collection URI (/widgets/):   |   index   |   replace |   create  |   drop
+    # Element URI   (/widgets/42):  |   show    |   update  |   add     |   destroy
+
+    #def index;       end
+    #def replace;     end
+    #def create;      end
+    #def drop;        end
+    #def show(id);    end
+    #def update(id);  end
+    #def add(id);     end
+    #def destroy(id); end
+
+    def method_missing(method_sym, *arguments, &block)
+      raise HTTP405MethodNotAllowed, 'Method not provided on controller.'
+    end
+
+    protected # all internal methods are protected rather than private so that calling methods *could* be overriden if necessary.
+    def self.has_relationship_to(entity, opts = {})
+      # This method allows one to access a related resource, without providing a direct link to specific relation(s).
+      entity_name = opts[:as] || entity
+      define_method( entity_name.to_sym,
+        Proc.new do
+          @resource_request.id, @resource_request.action = nil, nil
+          ( @resource_request.id, @resource_request.action, @resource_request.path_stack ) = @resource_request.path_stack.split('/', 3) unless @resource_request.path_stack.blank?
+          if [ :index, :replace, :create, :destroy ].include? @resource_request.id
+            @resource_request.action = @resource_request.id
+            @resource_request.id = nil
+          end
+          format_id
+          self.call_relation(entity)
+        end
+      )
+    end
+
+    def self.has_direct_relationship_to(entity, opts = {}, &get_entity_id_from_relation_id)
+      # This method defines that there is a single link to a member from an entity collection.
+      # The second parameter is an options hash to support setting the local name of the relation via ':as => :foo'.
+      # The third parameter to the method is a Proc which accepts the calling entity's id and returns the id of the relation to which we're establishing the link.
+      # This adds an accessor instance method whose name is the entity's class.
+      entity_name = opts[:as] || entity
+      define_method( entity_name.to_sym,
+        Proc.new do
+          @resource_request.id = get_entity_id_from_relation_id.call(@resource_request.id)
+          @resource_request.action = nil
+          ( @resource_request.action, @resource_request.path_stack ) = @resource_request.path_stack.split('/', 3) unless @resource_request.path_stack.blank?
+          format_id
+          self.call_relation(entity)
+        end
+      )
+    end
+
+    def self.has_direct_relationships_to(entity, opts = {}, &get_entity_id_from_relation_id)
+      # This method defines that there are multiple links to members from an entity collection (an array of entity identifiers).
+      # This adds an accessor instance method whose name is the entity's class.
+      entity_name = opts[:as] || entity
+      define_method( entity_name.to_sym,
+        Proc.new do
+          entity_array = get_entity_id_from_relation_id.call(@resource_request.id)
+          @resource_request.id, @resource_request.action = nil, nil
+          ( @resource_request.id, @resource_request.action, @resource_request.path_stack ) = @resource_request.path_stack.split('/', 3) unless @resource_request.path_stack.blank?
+          format_id
+          unless entity_array.include?( @resource_request.id )
+            raise HTTP404ResourceNotFound, 'Relation entity does not belong to referring resource.'
+          end
+          self.call_relation(entity)
+        end
+      )
+    end
+
+    def self.has_mapped_relationships_to(entity, opts = {}, &get_entity_id_from_relation_id)
+      # This method defines that there are mapped links to members from an entity collection (a hash of entity identifiers).
+      # This adds an accessor instance method whose name is the entity's class.
+      entity_name = opts[:as] || entity
+      define_method( entity_name.to_sym,
+        Proc.new do
+          entity_map = get_entity_id_from_relation_id.call(@resource_request.id)
+          @resource_request.action = nil
+          ( key, @resource_request.action, @resource_request.path_stack ) = @resource_request.path_stack.split('/', 3) unless @resource_request.path_stack.blank?
+          format_id
+          unless @resource_request.id = entity_map[key.to_sym]
+            raise HTTP404ResourceNotFound, 'Relation entity does not belong to referring resource.'
+          end
+          self.call_relation(entity)
+        end
+      )
+    end
+
+    def call_relation(entity)
+      # Call the child relation (next entity in the path stack)
+      # common logic to all relationship methods
+      @resource_request.resource_name = entity.to_s.camelize
+      setup_action
+      @resource_request.locate
+      @resource_request.call
+    end
+
+    def setup_action
+      # If the action is not set with the request URI, determine the action from HTTP Verb.
+      if @resource_request.action.blank?
+        if @resource_request.request.get?
+          @resource_request.action = @resource_request.id.blank? ? :index   : :show
+        elsif @resource_request.request.put?
+          @resource_request.action = @resource_request.id.blank? ? :replace : :update
+        elsif @resource_request.request.post?
+          @resource_request.action = @resource_request.id.blank? ? :create  : :add
+        elsif @resource_request.request.delete?
+          @resource_request.action = @resource_request.id.blank? ? :drop    : :destroy
+        else
+          raise HTTP405MethodNotAllowed, 'Action not provided or found and unknown HTTP request method.'
+        end
+      end
+    end
+
+    def self.keyed_with_type(klass)
+      # Allows decendent controllers to set a data type for the id other than the default.
+      @@key_type = klass
+    end
+
+    def format_id
+      # This method is used to convert the id coming off of the path stack, which is in string form, into another data type if one has been set.
+      @@key_type ||= nil
+      unless @@key_type.blank?
+        if @@key_type == Fixnum
+          @resource_request.id = @resource_request.id.to_i
+        elsif @@key_type == Float
+          @resource_request.id = @resource_request.id.to_f
+        else
+          raise HTTP500ServerError, "Invalid key identifier type specified on resource #{self.class.to_s}."
+        end
+      else
+        @@key_type = String
+      end
+    end
+
+    def package(data)
+      # This handles outputing properly formatted content based on the file extension in the URL.
+      if @resource_request.mime_type.like?( RESTRack.mime_type_for( :JSON ) )
+        @output = data.to_json
+      elsif @resource_request.mime_type.like?( RESTRack.mime_type_for( :XML ) )
+        if File.exists? builder_file
+          @output = builder_up(data)
+        else
+          @output = XmlSimple.xml_out(data, 'AttrPrefix' => true)
+        end
+      elsif @resource_request.mime_type.like?(RESTRack.mime_type_for( :YAML ) )
+        @output = YAML.dump(data)
+      elsif @resource_request.mime_type.like?(RESTRack.mime_type_for( :TEXT ) )
+        @output = data.to_s
+      else
+        @output = data
+      end
+    end
+
+    def builder_up(data)
+      # Use Builder to generate the XML
+      buffer = ''
+      xml = Builder::XmlMarkup.new(:target => buffer)
+      xml.instruct!
+      eval( File.new( builder_file ).read )
+      return buffer
+    end
+
+    def builder_file
+      "#{RESTRack::CONFIG[:ROOT]}/views/#{@resource_request.resource_name.underscore}/#{@resource_request.action}.xml.builder"
+    end
+
+  end # class ResourceController
+end # module RESTRack

data/lib/restrack/resource_request.rb

@@ -0,0 +1,135 @@
+module RESTRack
+  class ResourceRequest
+    attr_reader :request, :request_id, :input
+    attr_accessor :mime_type, :path_stack, :resource_name, :action, :id
+
+    def initialize(opts)
+      # Initialize the ResourceRequest by assigning a request_id and determining the path, format, and controller of the resource.
+      # Accepting options just to allow us to override request_id for testing.
+      @request = opts[:request]
+      @request_id = opts[:request_id] || get_request_id
+
+      # Write input details to logs
+      RESTRack.request_log.info "{#{@request_id}} #{@request.path_info} requested from #{@request.ip}"
+
+      RESTRack.log.debug "{#{@request_id}} Reading POST Input"
+
+      # Pull input data from POST body
+      @input = read( @request )
+
+      # Setup up the initial routing.
+      (@path_stack, extension)      = split_extension_from( @request.path_info )
+      @mime_type                    = get_mime_type_from( extension )
+      (@resource_name, @path_stack) = get_initial_resource_from( @path_stack )
+      (@id, @action, @path_stack)   = get_id_and_action_from( @path_stack )
+
+      # Verify that initial resource in the request chain is accessible at the root.
+      raise HTTP403Forbidden unless RESTRack::CONFIG[:ROOT_RESOURCE_ACCEPT].blank? or RESTRack::CONFIG[:ROOT_RESOURCE_ACCEPT].include?(@resource_name)
+      raise HTTP403Forbidden if not RESTRack::CONFIG[:ROOT_RESOURCE_DENY].blank? and RESTRack::CONFIG[:ROOT_RESOURCE_DENY].include?(@resource_name)
+    end
+
+    def locate
+      # Locate the correct controller of resource based on the request.
+      # The resource requested must be a member of RESTRack application or a 404 error will be thrown by RESTRack::WebService.
+      RESTRack.log.debug "{#{@request_id}} Locating Resource"
+      @resource = instantiate_controller
+    end
+
+    def call
+      # Pass along the `call` method to the typed resource object, this must occur after a call to locate.
+      RESTRack.log.debug "{#{@request_id}} Processing Request"
+      @resource.call
+    end
+
+    def output
+      # Send out the typed resource's output, this must occur after a call to run.
+      RESTRack.log.debug "{#{@request_id}} Retrieving Output"
+      @resource.output
+    end
+
+    def content_type
+      @mime_type.to_s
+    end
+
+    private
+    def get_request_id
+      t = Time.now
+      return t.strftime('%FT%T') + '.' + t.usec.to_s
+    end
+
+    def read(request)
+      input = ''
+      unless request.content_type.blank?
+        request_mime_type = MIME::Type.new( request.content_type )
+        if request_mime_type.like?( RESTRack.mime_type_for( :JSON ) )
+          input = JSON.parse( request.body.read )
+        elsif request_mime_type.like?( RESTRack.mime_type_for( :XML ) )
+          input = XmlSimple.xml_out( request.body.read )
+        elsif request_mime_type.like?( RESTRack.mime_type_for( :YAML ) )
+          input = YAML.parse( request.body.read )
+        elsif request_mime_type.like?( RESTRack.mime_type_for( :TEXT ) )
+          input = request.body.read.to_s
+        else
+          input = request.body.read
+        end
+        RESTRack.request_log.debug "{#{@request_id}} #{request_mime_type.to_s} data in\n" + input.to_json
+      end
+      input
+    end
+
+    def split_extension_from(path_stack)
+      # Remove the extension from the URL if present, that will be used to determine content-type.
+      extension = ''
+      unless path_stack.nil?
+        path_stack = path_stack.sub(/\.([^.]*)$/) do |s|
+          extension = $1.downcase
+          '' # Return an empty string as the substitution so that the extension is removed from `path_stack`
+        end
+      end
+      [path_stack, extension]
+    end
+
+    def get_mime_type_from(extension)
+      unless extension == ''
+        mime_type = RESTRack.mime_type_for( extension )
+      end
+      if mime_type.nil?
+        if RESTRack::CONFIG[:DEFAULT_FORMAT]
+          mime_type = RESTRack.mime_type_for( RESTRack::CONFIG[:DEFAULT_FORMAT].to_s.downcase )
+        else
+          mime_type = RESTRack.mime_type_for( :JSON )
+        end
+      end
+      mime_type
+    end
+
+    def get_initial_resource_from(orig_path_stack)
+      ( empty_str, resource_name, path_stack ) = orig_path_stack.split('/', 3)
+      if resource_name.blank? or not RESTRack.resource_exists? resource_name # treat as if request to default resource
+        raise HTTP404ResourceNotFound if RESTRack::CONFIG[:DEFAULT_RESOURCE].blank?
+        path_stack = orig_path_stack.sub(/^\//, '')
+        resource_name = RESTRack::CONFIG[:DEFAULT_RESOURCE]
+      end
+      [resource_name, path_stack]
+    end
+
+    def get_id_and_action_from(path_stack)
+      ( id, action, path_stack ) = (path_stack || '').split('/', 3)
+      if [ :index, :replace, :create, :destroy ].include? id
+        action = id
+        id = nil
+      end
+      [id, action, path_stack]
+    end
+
+    def instantiate_controller
+      # Called from the locate method, this method dynamically finds the class based on the URI and instantiates an object of that class via the __init method on RESTRack::ResourceController.
+      begin
+        return RESTRack.controller_class_for( @resource_name ).__init(self)
+      rescue
+        raise HTTP404ResourceNotFound, "The resource #{RESTRack::CONFIG[:SERVICE_NAME]}::#{RESTRack.controller_name(@resource_name)} could not be instantiated."
+      end
+    end
+
+  end # class ResourceRequest
+end # module RESTRack