rubyrest 0.0.3 → 0.0.4

data/CHANGELOG

@@ -1,8 +1,21 @@
+== What's next?
+
+* Introduce the concept of 'security authority' so that multiple deployed instances of rubyrest can be federated by a single authentication and authorization service.
+* Use mongrel as the HTTP server implementation, instead of WEBrick
+* Refactor code, style it more 'a la' Ruby.
+* Provide more complex examples, such as Database Configurations
+
+== Release 0.0.4
+
+* Module RubyRest::Client has been redesigned into class RubyRest::Client::Default which offers a higher level api by translating create, retrieve, update and delete method calls into proper HTTP GET, POST, PUT and DELETE requests.
+* Engine configurations are now externalized so they can be provided programmatically as Hashes or loaded from YAML files.
+* The rubyrest command line now supports different deployment environments (dev, live)
+
 == Release 0.0.3
 
 * Added module RubyRest::Client, providing a convenience client to REST APIs deployed with Ruby-on-Rest
 * Improved Atom representation of resources (feeds, entries and service documents)
-* Dashboard (service document) can now be customized by developpers by implementing a class with name Dashboard.
+* Dashboard (service document) can now be customized by developers by implementing a class with name Dashboard.
 
 == Release 0.0.2
 

data/README

@@ -30,15 +30,27 @@ If you have any comments or suggestions please send an email to pedro dot gutier
 
 Please have a look at the examples provided, they are simple enough to let you grasp how rubyrest works.
 
-=== Starting and stopping the service
+=== Starting the service
 
 Ruby-on-Rest provides a shell command. Open your console, and type the following:
  
-  rubyrest start|stop <my_service> [<my_service_module>]
+  rubyrest dev <my_service> (for development deployment)
+  rubyrest live <my_service> (for live deployment)
 
-Ruby-on-Rest can also be embedded in ruby code. This is useful for testing purposes:
+This will first look at a YAML file called <my_service>_dev.yaml or <my_service>_live.yaml under the 
+current path.
 
-  engine = RubyRest::Engine.new( <my_service>, <my_service_module> )
+Ruby-on-Rest can also be embedded in ruby code. This is useful for testing purposes:
+	
+  config = {
+	"service" => "hello",
+	"prefix" => "acme",
+	"serviceport" => 9003
+	"daemon" => true
+	"entities" => [ "welcomeservice" ]
+  }	
+	
+  engine = RubyRest::Engine.new( config )
   engine.start
   # ...	
   # do some http calls here
@@ -48,7 +60,8 @@ Ruby-on-Rest can also be embedded in ruby code. This is useful for testing purpo
 
 === 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.
+Ruby-on-Rest will try to load a file name <my_service>.rb which provides the implementation of the service.
+
+
 
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "rubyrest"
-VERS = "0.0.3"
+VERS = "0.0.4"
 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

@@ -7,20 +7,24 @@ require 'rubygems'
 require 'rubyrest'
 
 service = ARGV[1]
-prefix = ARGV[2]
-action = ARGV[0]
+deploy_mode = ARGV[0] 
 
-if action == nil or ( action != "start" and  action != "stop" )  or service == nil
-  puts "Usage: rubyrest start|stop <your_service> "
+if service == nil or deploy_mode == nil
+  puts "Usage: rubyrest dev|live <your_service>"
   puts "Ruby-on-Rest: Simple REST for Ruby."
   puts
   puts "Examples:"
-  puts "  rubyrest start grape"
-  puts "  rubyrest stop grape"
+  puts "  rubyrest dev grape"
+  puts "  rubyrest live grape"
   puts
   puts "For more information see http://rubyrest.rubyforge.org"
 else
-  engine = RubyRest::Engine.new( service, prefix )
-  engine.method( action ).call
+  # load the yaml file for the 
+  # deploy specific configuration, and build a hash out of it
+  params = YAML::load_file( "#{service}_#{deploy_mode}.yaml" )
+  params[ "service" ] = service
+  
+  engine = RubyRest::Engine.new( params )
+  engine.start
 end
 

data/examples/hello.rb

@@ -11,18 +11,18 @@ module Acme
     # 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 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

data/lib/rubyrest/atom.rb

@@ -167,6 +167,13 @@ module RubyRest
           def id
             text( "/entry/moodisland:content/id" )
           end
+          
+          # Overrides the default implementation
+          # by returning a new Ruby-on-Rest Atom Document
+          def clone
+            self.class.new self.to_s
+          end
+          
         end
 
       end

data/lib/rubyrest/client.rb

@@ -4,69 +4,131 @@ module RubyRest
   # to REST services offered by Ruby-on-REST. 
   module Client
     
-    # Builds a headers hash, with the specified 
-    # authorization token if not nil
-    def prepare_headers( auth = nil )
-      headers = { "Content-Type" => "text/xml; charset=utf-8" }
-      headers[ "token" ] = auth if auth != nil 
-      return headers
-    end
-    
-    # Reusable method that builds an Atom entry out of the specified hash of data
-    def hash2entry( data )
-      doc = RubyRest::Atom::Entry::Document.new
-      entry = REXML::Element.new( "entry", doc  )
-      content = REXML::Element.new( "content", entry )
-      data.each { |name,value| 
-        body = REXML::Element.new( name.to_s, content )
-        body.text = value
-      }
-      return doc
-    end
-    
-    # Parses the response body string as a Ruby-on-Rest Entry document,
-    def str2entry( rsp )
-      begin
-        RubyRest::Atom::Entry::Document.new( rsp.body ) if response.body
-      rescue => e
-        return nil
+    # 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
+      
+      # Configures the server name and port 
+      def self.with_server name, port
+        @host = name
+        @port = port
       end
+      
+      # Returns the hostname of the service to 
+      # connect to
+      def self.host
+        @host
+      end
+      
+      # Returns the port number on which to 
+      # connect to
+      def self.port
+        @port 
+      end
+      
+      # Converts the specified hash of data into a
+      # query string, then performs a GET http request.
+      # The response body is returned as an an Atom document if 
+      # the response status code is 200.
+      def retrieve( path, data, api_key )
+        path << to_query_string( data ) if data
+        headers = prepare_headers( api_key )
+        rsp = http.get( path, headers )
+        return to_xml( rsp ) if rsp.code.to_i == 200
+      end
+      
+      # Converts the specified hash of data into a
+      # simplified Atom Entry, then performs a POST http request.
+      # The response body is returned as an an Atom Entry if 
+      # the response status code is 201.
+      def create( path, data, api_key )
+        body = nil
+        body = hash2entry( data ).to_s if data != nil
+        headers = prepare_headers( api_key )
+        rsp = http.post( path, body, headers )
+        return to_xml( rsp ) if rsp.code.to_i == 201
+      end
+      
+      # Converts the specified hash of data into a
+      # simplified Atom Entry, then performs a PUT http request.
+      # The response body is returned as an an Atom Entry if 
+      # the response status code is 200.
+      def update( path, data, api_key )
+        body = nil
+        body = hash2entry( data ).to_s if data != nil
+        headers = prepare_headers( api_key )
+        rsp = http.put( path, body, headers )
+        return to_xml( rsp ) if rsp.code.to_i == 200
+      end
+      
+      # Converts the specified hash of data into a
+      # query string, then performs a DELETE http request.
+      # This method simply returns the response status code
+      def delete( path, data, api_key )
+        path << to_query_string( data ) if data
+        headers = prepare_headers( api_key )
+        rsp = http.delete( path, headers )
+        rsp.code.to_i
+      end
+      
+      # Convenience method that returns the 
+      # service document from the service endpoint
+      def dashboard( api_key )
+        retrieve( "/", nil, api_key )
+      end
+      
+      # Convenience method that returns a new HTTP object
+      # for each call
+      def http
+        Net::HTTP.new( self.class.host, self.class.port )
+      end
+      
+      # Builds a headers hash, with the specified 
+      # authorization token if not nil
+      def prepare_headers( api_key = nil )
+        headers = { "Content-Type" => "text/xml; charset=utf-8" }
+        headers[ "token" ] = api_key if api_key != nil 
+        return headers
+      end
+      
+      # Converts the specified hash of data into a simplified
+      # Atom Entry document.
+      def hash2entry( data )
+        doc = RubyRest::Atom::Entry::Document.new
+        entry = REXML::Element.new( "entry", doc  )
+        content = REXML::Element.new( "content", entry )
+        data.each { |name,value| 
+          body = REXML::Element.new( name.to_s, content )
+          body.text = value
+        }
+        return doc
+      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 )
+        begin
+          RubyRest::Atom::Entry::Document.new( rsp.body ) if rsp.body
+        rescue => e
+          puts "unable to parse response body: " + e.message
+          puts "---- response body ----"
+          puts rsp.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!
+      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!
-    end
-    
-    # Performs a POST request and returns the raw response object
-    # The data (a hash of name,value pairs) is converted to an
-    # simplified Atom Entry
-    def post( server, port, path, data, token )
-      body = nil
-      body = hash2entry( data ).to_s if data != nil
-      headers = prepare_headers( token )
-      rsp = Net::HTTP.new( server, port ).post( path, body, headers )
-      [ rsp.code.to_i, str2entry( rsp ) ] 
-    end
-    
-    # Performs a GET request and returns the raw response object
-    # The data (a hash of name,value pairs) is converted to a query
-    # string, then concatenated to the path.
-    def get( server, port, path, data, token )
-      path << to_query_string( data ) if data
-      headers = prepare_headers( token )
-      rsp = Net::HTTP.new( server, port ).get( path, headers )
-      [ rsp.code.to_i, str2entry( rsp ) ] 
-    end
-    
-   
-    
   end
   
- 
-  
-  
 end

data/lib/rubyrest/config.rb

@@ -13,11 +13,7 @@ module RubyRest
   #
   #   module MyService
   #     class Config < RubyRest::SimpleConfig
-  #       def initialize
-  #         @hash = { 
-  #            ... my config here ..
-  #         }
-  #       end
+  #       
   #     end
   #   end
   #
@@ -25,6 +21,12 @@ module RubyRest
   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 )
@@ -45,7 +47,7 @@ module RubyRest
 
      # Dumps all the configuration options
      def to_s
-       @hash.each{ |k,v| puts "#{k} = #{v}" }
+       @hash.each{ |k,v| puts "key: #{k}, value: #{v}" }
      end
      
   end
@@ -60,7 +62,7 @@ module RubyRest
     # will delegate to a more specialized method, according to the
     # :adapter config option
     def connect_to_database
-      adapter_method = "#{@hash[:dbadapter]}_connect"
+      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

data/lib/rubyrest/engine.rb

@@ -14,14 +14,18 @@ module RubyRest
     # engine configuration
     attr_reader :config
     
-    # Creates a new RubyRest engine, for the service 
-    # and service prefix
-    def initialize( service, prefix = nil )
-      @service = service
-      @prefix = prefix
+    # 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
+      @config = to_class( service_module, "config" ).new( params )
       @config[ :servicemodule ] = service_module
     end
     
@@ -31,7 +35,7 @@ module RubyRest
     #   2. launch the webserver, in daemon mode unless false is 
     # specified in the configuration
     def start
-      configure_database if @config.has( :dbadapter )
+      configure_database if @config.has( :adapter )
       @server = RubyRest::Server.new( @config )
       @server.mount "/", CRUDServlet
       if @config.has( :daemon ) and @config[ :daemon ] == false 
@@ -51,7 +55,7 @@ module RubyRest
     def configure_database
       @config.connect_to_database
       @config.setup_persistence
-      if @config[ :dbdestroy ] == true
+      if @config[ :destroy ] == true
         @config.init_schema
         @config.load_initial_data
       end

data/lib/rubyrest/servlets.rb

@@ -38,7 +38,11 @@ module RubyRest
       @model = params[1]
       @id = params[2]
       @property = params[3]
-      @body = REXML::Document.new( request.body ) if request.body != nil
+      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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.1
 specification_version: 1
 name: rubyrest
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
-date: 2007-04-08 00:00:00 +02:00
+  version: 0.0.4
+date: 2007-04-15 00:00:00 +02:00
 summary: REST framework for Ruby.
 require_paths: 
 - lib