dima-ruboss4ruby 1.1.0 → 1.1.1

data/generators/ruboss_controller/templates/restful.py

@@ -0,0 +1,136 @@
+# The MIT License
+# 
+# Copyright (c) 2008 William T. Katz
+# 
+# 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.
+ 
+"""
+RESTful Controller
+ 
+We want our RESTful controllers to simply throw up their hands if they get
+an unhandled HTTP verb.  This is better for rich clients and server load
+than throwing back lots of useless HTML.
+ 
+These inherited methods should be overridden if there's a chance a human
+browser is involved.
+ 
+TODO: Return more information HTTP status codes that won't autotrip 
+browser login forms.  For example, return status 405 (Method not allowed) 
+with an Allow header containing the list of valid methods.
+"""
+__author__ = 'William T. Katz'
+ 
+from google.appengine.ext import webapp
+ 
+import logging
+ 
+# Some useful module methods
+def send_successful_response(handler, response):
+    logging.debug("Sending successful response: %s", response)
+    handler.response.headers["Content-Type"] = "application/xml"
+    handler.response.out.write('<?xml version="1.0" encoding="UTF-8"?>')
+    handler.response.out.write(response)
+    
+def get_model_key(handler):
+  return handler.request.path_info.split("/").pop().replace(".xml", "")
+ 
+def get_sent_properties(request_func, propname_list):
+    """
+    This maps request strings to values in a hash, optionally run through 
+    a function with previous request values as parameters to the func.
+    1) key -> just read in the corresponding request value
+    2) tuple (key, func) -> Read the request value for the string key
+        and pass it through func
+    3) tuple (key, func, additional keys...) -> Get the request
+        values for the additional keys and pass them through func
+        before setting the key's value with the output.
+    If a key is not present in the request, then we do not insert a key
+    with None or empty string.  The key is simply absent, therefore allowing
+    you to use the returned hash to initial a Model instance.
+    """
+    prop_hash = {}
+    for item in propname_list:
+        if isinstance(item, basestring):
+            key = item
+            value = request_func(item)
+        elif isinstance(item, tuple):
+            key = item[0]
+            prop_func = item[1]
+            if len(item) <= 2:
+                value = prop_func(request_func(key))
+            else:
+                try:
+                    addl_keys = map(prop_hash.get, item[2:])
+                    value = prop_func(*addl_keys)
+                except:
+                    return None
+        if value:
+            prop_hash[key] = value
+    return prop_hash
+ 
+def methods_via_query_allowed(handler_method):
+    """
+    A decorator to automatically re-route overloaded POSTs
+    that specify the real HTTP method in a _method query string.
+ 
+    To use it, decorate your post method like this:
+ 
+    import restful
+    ...
+    @restful.methods_via_query_allowed
+    def post(self):
+      pass
+ 
+    The decorator will check for a _method query string or POST argument,
+    and if present, will redirect to delete(), put(), etc.
+    """
+    def redirect_if_needed(self, *args, **kwargs):
+        real_verb = self.request.get('_method', None)
+        if not real_verb and 'X-HTTP-Method-Override' in self.request.environ:
+            real_verb = self.request.environ['X-HTTP-Method-Override']
+        if real_verb:
+            logging.debug("Redirected from POST. Detected method override = %s", real_verb)
+            method = real_verb.upper()
+            if method == 'HEAD':
+                self.head(*args, **kwargs)
+            elif method == 'PUT':
+                self.put(*args, **kwargs)
+            elif method == 'DELETE':
+                self.delete(*args, **kwargs)
+            elif method == 'TRACE':
+                self.trace(*args, **kwargs)
+            elif method == 'OPTIONS':
+                self.head(*args, **kwargs)
+            # POST and GET included for completeness
+            elif method == 'POST':
+                self.post(*args, **kwargs)
+            elif method == 'GET':
+                self.get(*args, **kwargs)
+            else:
+                self.error(405)
+        else:
+            handler_method(self, *args, **kwargs)
+    return redirect_if_needed
+ 
+class Controller(webapp.RequestHandler):
+    def get(self, *params):
+        self.redirect("/403.html")
+ 
+    def head(self, *params):
+        pass

data/generators/ruboss_main_app/ruboss_main_app_generator.rb

@@ -7,9 +7,10 @@ class RubossMainAppGenerator < RubiGen::Base
               :base_folder, 
               :command_controller_name,
               :model_names, 
-              :command_names,
               :component_names,
+              :controller_names,
               :use_air,
+              :use_gae,
               :application_tag
 
   def initialize(runtime_args, runtime_options = {})
@@ -31,16 +32,29 @@ class RubossMainAppGenerator < RubiGen::Base
     if File.exists?("app/flex/#{base_folder}/components/generated")
       @component_names = list_mxml_files("app/flex/#{base_folder}/components/generated")
     end
+    
+    @controller_names = []
+    if options[:gae] && File.exists?("app/controllers")
+      @use_gae = true
+      @controller_names = 
+        Dir.entries("app/controllers").grep(/\.py$/).delete_if { |name| name == "__init__.py" || name == "restful.py" }.map { |name| name.sub(/\.py$/, "") }
+    end
   end
 
   def manifest
     record do |m|      
       m.template 'mainapp.mxml', File.join('app', 'flex', "#{project_name}.mxml")
+      if options[:gae]
+        m.template 'main.py.erb', 'main.py'
+      end
     end
   end
 
   protected
-    def banner
-      "Usage: #{$0} #{spec.name}" 
-    end
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--gae", "Generate Google App Engine Python classes in addition to Ruboss Flex resources.", 
+      "Default: false") { |v| options[:gae] = v }
+  end
 end

data/generators/ruboss_main_app/templates/main.py.erb

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+import logging
+import wsgiref.handlers
+
+from google.appengine.api import users
+from google.appengine.ext import webapp
+from google.appengine.ext.webapp.util import run_wsgi_app
+from app.controllers import <%= controller_names.join(", ") %>
+
+class AppController(webapp.RequestHandler):
+  def get(self):
+    self.redirect("/public/index.html")
+
+def main():
+  application = webapp.WSGIApplication(
+  [('/*$', AppController), 
+<% for component in controller_names -%>
+<% if component == controller_names.last -%>
+  ('/<%= component %>.*', <%= component %>.Controller)
+<% else -%>
+  ('/<%= component %>.*', <%= component %>.Controller),
+<% end -%>
+<% end -%>
+  ], debug=True)
+  wsgiref.handlers.CGIHandler().run(application)
+
+if __name__ == '__main__':
+  main()

data/generators/ruboss_main_app/templates/mainapp.mxml

@@ -8,12 +8,16 @@
 <% if use_air -%>
       import org.ruboss.services.air.AIRServiceProvider;
 <% end -%>
-      import org.ruboss.Ruboss;
+<% if use_gae -%>
+      import org.ruboss.services.http.GAEHTTPServiceProvider;
+<% end -%>
       import <%= base_package %>.controllers.<%= command_controller_name %>;
 
       private function init():void {
 <% if use_air -%>
         <%= command_controller_name %>.initialize([AIRServiceProvider], AIRServiceProvider.ID, "<%= base_package %>");
+<% elsif use_gae -%>
+        <%= command_controller_name %>.initialize([GAEHTTPServiceProvider], GAEHTTPServiceProvider.ID);
 <% else -%>
         <%= command_controller_name %>.initialize();
 <% end -%>

data/generators/ruboss_scaffold/ruboss_scaffold_generator.rb

@@ -10,22 +10,48 @@ module Ruboss4Ruby
       
       def flex_type
         @flex_type = case type
-          when :integer                     then 'int'
-          when :date, :datetime, :time      then 'Date'
-          when :boolean                     then 'Boolean'
-          when :float, :decimal             then 'Number'
-          else
-            'String'
+        when :integer                     then 'int'
+        when :date, :datetime, :time      then 'Date'
+        when :boolean                     then 'Boolean'
+        when :float, :decimal             then 'Number'
+        else
+          'String'
         end
       end
       
-      def flex_default(prefix = '')
+      def flex_default
         @flex_default = case type
-          when :integer, :float, :decimal   then '0'
-          when :string, :text               then '""'
-          when :boolean                     then 'false'
-          else
-            'null'
+        when :integer                 then '0'
+        when :date, :datetime, :time  then 'new Date'
+        when :boolean                 then 'false'
+        when :float, :decimal         then 'new Number'
+        else
+          "\"\""
+        end
+      end
+      
+      def gae_type
+        @gae_type = case type
+        when :integer     then 'IntegerProperty'
+        when :date        then 'DateProperty'
+        when :time        then 'TimeProperty'
+        when :datetime    then 'DateTimeProperty'
+        when :boolean     then 'BooleanProperty'
+        when :text        then 'TextProperty'
+        when :float, :decimal then 'FloatProperty'
+        else
+          'StringProperty'
+        end
+      end
+      
+      def gae_default
+        @gae_default = case type
+        when :integer                then 'default = 0'
+        when :date, :time, :datetime then 'auto_now_add = True'
+        when :boolean                then 'default = False'
+        when :float, :decimal        then 'default = 0.0'
+        else
+          ""
         end
       end
     end
@@ -48,9 +74,7 @@ class RubossScaffoldGenerator < RubiGen::Base
   attr_reader   :name,
                 :class_name,
                 :file_name
-                                
-  attr_accessor :constructor_args
-      
+                                      
   def initialize(runtime_args, runtime_options = {})
     super
 
@@ -62,8 +86,34 @@ class RubossScaffoldGenerator < RubiGen::Base
     @file_name = @name.underscore
     @class_name = @name.camelize
     
-    @project_name, @flex_project_name, @command_controller_name, @base_package, @base_folder = extract_names
-    
+    @project_name, @flex_project_name, @command_controller_name, 
+      @base_package, @base_folder = extract_names
+    extract_relationships
+  end
+  
+  def manifest
+    record do |m|      
+      m.template 'model.as.erb',
+        File.join("app", 'flex', base_folder, "models", "#{@class_name}.as"), 
+        :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
+
+      m.template 'component.mxml.erb',
+        File.join("app", 'flex', base_folder, "components", "generated", "#{@class_name}Box.mxml"), 
+        :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
+        
+      if options[:gae]
+        m.template 'controller.py.erb', "app/controllers/#{file_name.pluralize}.py"
+        m.template 'model.py.erb', "app/models/#{file_name}.py"
+      end
+
+      # Run the rcontroller generator to clobber the
+      # RubossCommandController subclass to include the new models.
+      m.dependency 'ruboss_controller', [name] + @args, :collision => :force, :gae => options[:gae]
+    end
+  end
+  
+  protected
+  def extract_relationships
     @belongs_tos = []
     @has_ones = []
     @has_manies = []
@@ -80,38 +130,19 @@ class RubossScaffoldGenerator < RubiGen::Base
       end
     end
     
-    # Remove the has_one and has_many arguments since they are
-    # not for consumption by the scaffold generator, and since
-    # we have already used them to set the @belongs_tos, @has_ones and
-    # @has_manies.
     @args.delete_if { |elt| elt =~ /^(has_one|has_many|belongs_to):/ }
   end
-  
-  def manifest
-    record do |m|      
-      # Generate Flex AS model and MXML component based on the
-      # Ruboss templates.
-      
-      puts @file_name
-      
-      m.template 'model.as.erb',
-        File.join("app", 'flex', base_folder, "models", "#{@class_name}.as"), 
-        :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
 
-      m.template 'component.mxml.erb',
-        File.join("app", 'flex', base_folder, "components", "generated", "#{@class_name}Box.mxml"), 
-        :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
-
-      # Run the rcontroller generator to clobber the
-      # RubossCommandController subclass to include the new models.
-      m.dependency 'ruboss_controller', [name] + @args, :collision => :force
+  def attributes
+    @attributes ||= @args.collect do |attribute|
+      Ruboss4Ruby::Generator::GeneratedAttribute.new(*attribute.split(":"))
     end
   end
-  
-  protected
-    def attributes
-      @attributes ||= @args.collect do |attribute|
-        Ruboss4Ruby::Generator::GeneratedAttribute.new(*attribute.split(":"))
-      end
-    end
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--gae", "Generate Google App Engine Python classes in addition to Ruboss Flex resources.", 
+      "Default: false") { |v| options[:gae] = v }
+  end
 end

data/generators/ruboss_scaffold/templates/controller.py.erb

@@ -0,0 +1,27 @@
+import restful
+import logging
+
+from google.appengine.ext import webapp
+from google.appengine.api import users
+from google.appengine.ext import db
+from app.models import assist, <%= file_name %>
+
+class Controller(restful.Controller):
+  def get(self):
+    restful.send_successful_response(self, assist.all(<%= file_name %>.<%= class_name %>))
+    
+  @restful.methods_via_query_allowed
+  def post(self):
+    model = <%= file_name %>.<%= class_name %>()
+    assist.update_model_from_params(model, self.request.params)
+    restful.send_successful_response(self, model.to_xml())
+    
+  def put(self):
+    model = <%= file_name %>.<%= class_name %>.get(db.Key(restful.get_model_key(self)))
+    assist.update_model_from_params(model, self.request.params)
+    restful.send_successful_response(self, model.to_xml())
+    
+  def delete(self):
+    model = <%= file_name %>.<%= class_name %>.get(db.Key(restful.get_model_key(self)))
+    db.delete(model)
+    restful.send_successful_response(self, model.to_xml())

data/generators/ruboss_scaffold/templates/model.as.erb

@@ -17,7 +17,7 @@ package <%= base_package %>.models {
 <% if attribute.type == :datetime || attribute.type == :time -%>
     [DateTime]
 <% end -%>
-    public var <%= attribute.flex_name %>:<%= attribute.flex_type %>;
+    public var <%= attribute.flex_name %>:<%= attribute.flex_type %> = <%= attribute.flex_default %>;
 
 <% end -%>
 <% for model in belongs_tos -%>

data/generators/ruboss_scaffold/templates/model.py.erb

@@ -0,0 +1,14 @@
+from google.appengine.ext import db
+<% if belongs_tos.length > 0 -%>
+import <%= belongs_tos.join(", ") %>
+<% end -%>
+
+class <%= class_name %>(db.Model):
+<% for attribute in attributes -%>
+  <%= attribute.name %> = db.<%= attribute.gae_type %>(<%= attribute.gae_default %>)
+<% end -%>
+<% for model in belongs_tos -%>
+  <%= model %> = db.ReferenceProperty(<%= model %>.<%= model.camelcase %>)
+<% end -%>
+  
+  

data/generators/ruboss_yaml_scaffold/USAGE

@@ -1,7 +1,45 @@
 Description:
-    Scaffolds an entire application based on db/model.yml file. This generator
-    transforms entries in db/model.yml into command line calls to 
-    "ruboss_scaffold".
+    Scaffolds an entire application based on db/model.yml file.
+    
+    This generator transforms entries in db/model.yml into 
+    command line calls to "ruboss_scaffold".
 
 Examples:
-    `./script/generate ruboss_yaml_scaffold`
+    `./script/generate ruboss_yaml_scaffold`
+    
+Sample Model File:
+    project:
+     - name: string
+     - notes: text
+     - start_date: date
+     - end_date: date
+     - completed: boolean
+     - belongs_to: [user]
+     - has_many: [tasks]
+
+    location:
+     - name: string
+     - notes: text
+     - belongs_to: [user]
+     - has_many: [tasks]
+
+    task:
+     - name: string
+     - notes: text
+     - start_time: datetime
+     - end_time: datetime
+     - completed: boolean
+     - next_action: boolean
+     - belongs_to: [project, location, user]
+
+    note:
+     - content: text
+     - belongs_to: [user]
+
+    user:
+     - login: string
+     - first_name: string
+     - last_name: string
+     - email: string
+     - has_many: [tasks, projects, locations]
+     - has_one: [note]