rlmattax-restfulx 1.2.4.1

data/rails_generators/rx_yaml_scaffold/USAGE

@@ -0,0 +1,51 @@
+Description:
+    Scaffolds an entire application based on db/model.yml file. This generator
+    transforms entries in db/model.yml into command line calls to 
+    "rx_scaffold".
+    
+    rx_scaffold delegates the underlying rails code generation to "scaffold"
+    and extends it in a number of ways:
+      1. Generates all required Flex code.
+      2. You can pass special belongs_to, has_one and has_many attributes
+         to generate *all* appropriate relationships. No more manual code
+         editing.
+
+Examples:
+    `./script/generate rx_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]

data/rails_generators/rx_yaml_scaffold/rx_yaml_scaffold_generator.rb

@@ -0,0 +1,68 @@
+require 'yaml'
+
+class RxYamlScaffoldGenerator < Rails::Generator::Base
+  def extract_attrs(line, attrs)
+    attrs.each do |key,value|
+      if value.class == Array
+        line << " #{key}:#{value.join(',')}"
+      else
+        line << " #{key}:#{value}"
+      end    
+    end
+    line
+  end
+  
+  def manifest
+    record do |m|
+      models = YAML.load(File.open(File.join(RAILS_ROOT, 'db/model.yml'), 'r'))
+      models.each do |model|
+        line = ""
+        attrs = model[1]
+        if attrs.class == Array
+          attrs.each do |elm|
+            line = extract_attrs(line, elm)
+          end
+        else
+          line = extract_attrs(line, attrs)
+        end
+        line = model[0].camelcase + " " + line
+        
+        if ARGV.size > 0
+          ARGV.each do |arg|
+            if model[0].camelcase == arg
+              puts 'running: rx_scaffold ' + line
+              Rails::Generator::Scripts::Generate.new.run(["rx_scaffold"] + line.split, 
+                :flex_only => options[:flex_only],
+                :flex_view_only => options[:flex_view_only],
+                :rails_only => options[:rails_only])
+              puts 'done ...'
+              sleep 1
+            end
+          end
+        else
+          puts 'running: rx_scaffold ' + line
+          Rails::Generator::Scripts::Generate.new.run(["rx_scaffold"] + line.split, 
+            :flex_only => options[:flex_only],
+            :flex_view_only => options[:flex_view_only],
+            :rails_only => options[:rails_only])
+          puts 'done ...'
+          sleep 1
+        end
+      end
+      
+      Rails::Generator::Scripts::Generate.new.run(["rx_main_app"])
+    end
+  end
+
+  protected
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("-f", "--flex-only", "Only generate the Flex/AIR files", 
+      "Default: false") { |v| options[:flex_only] = v }
+    opt.on("-r", "--rails-only", "Only generate the Rails files", 
+      "Default: false") { |v| options[:rails_only] = v }
+    opt.on("-fv", "--flex-view-only", "Only generate the Flex component files", 
+      "Default: false") { |v| options[:flex_view_only] = v }
+  end
+end

data/rxgen_generators/rx_config/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Fetches the latest published RestfulX Framework SWC file.
+
+Examples:
+    `./script/generate rx_config`

data/rxgen_generators/rx_config/rx_config_generator.rb

@@ -0,0 +1,21 @@
+require 'open-uri'
+
+class RxConfigGenerator < RubiGen::Base
+  include RestfulX::Configuration
+
+  def manifest
+    record do |m|        
+      framework_release = RestfulX::FRAMEWORK_VERSION
+      framework_distribution_url = "http://restfulx.github.com/releases/restfulx-#{framework_release}.swc"
+      framework_destination_file = "lib/restfulx-#{framework_release}.swc"
+      
+      if !options[:skip_framework] && !File.exist?(framework_destination_file)
+        puts "fetching #{framework_release} framework binary from: #{framework_distribution_url} ..."
+        open(framework_destination_file, "wb").write(open(framework_distribution_url).read)
+        puts "done. saved to #{framework_destination_file}"
+      end
+
+      m.dependency 'rx_controller', @args
+    end
+  end
+end

data/rxgen_generators/rx_controller/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Generates/updates the main Flex application controller, typically
+    app/flex/<yourappname>/controllers/ApplicationController.as
+    
+    It pulls out all available models and commands from respective
+    folders and makes sure they'll be pulled into the Flex application
+    at runtime. Doesn't require any arguments or options.
+
+Examples:
+    `./script/generate rx_controller`

data/rxgen_generators/rx_controller/rx_controller_generator.rb

@@ -0,0 +1,41 @@
+class RxControllerGenerator < RubiGen::Base
+  include RestfulX::Configuration
+  
+  attr_reader :project_name, 
+              :flex_project_name, 
+              :base_package, 
+              :base_folder, 
+              :command_controller_name,
+              :model_names, 
+              :command_names,
+              :flex_root
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @project_name, @flex_project_name, @command_controller_name, 
+      @base_package, @base_folder, @flex_root = extract_names
+    
+    @model_names = list_as_files("#{flex_root}/#{base_folder}/models")
+    @command_names = list_as_files("#{flex_root}/#{base_folder}/commands")
+  end
+
+  def manifest
+    record do |m|
+      m.template 'controller.as.erb', File.join("#{flex_root}/#{base_folder}/controllers", 
+        "#{command_controller_name}.as")
+      if options[:gae]
+        m.file 'restful.py', 'app/controllers/restful.py' if !File.exist?('app/controllers/restful.py')
+        m.file 'assist.py', 'app/models/assist.py' if !File.exist?('app/models/assist.py')
+        m.file 'iso8601.py', 'app/models/iso8601.py' if !File.exist?('app/models/iso8601.py')
+      end
+    end
+  end
+
+  protected
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--gae", "Generate Google App Engine Python classes in addition to RestfulX Flex resources.", 
+      "Default: false") { |v| options[:gae] = v }
+  end
+end

data/rxgen_generators/rx_controller/templates/assist.py

@@ -0,0 +1,65 @@
+# The MIT License
+# 
+# Copyright (c) 2008 Dima Berastau
+# 
+# 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.
+
+__author__ = 'Dima Berastau'
+
+from google.appengine.ext import db
+import datetime, iso8601
+
+# Some useful module methods
+def all(model):
+  items = "".join(str(item.to_xml().encode('UTF-8')) for item in model.all())
+  if items == "":
+    return '<entities type="array"/>'
+  else:
+    return '<entities kind="%s" type="array">%s</entities>' % (model.kind(), items)
+
+def update_model_from_params(model, params):
+  for k, v in params.items():
+    if k.endswith("_id"):
+      if v == "":
+        setattr(model, k.replace("_id", ""), None)
+      else:
+        setattr(model, k.replace("_id", ""), db.Key(v))
+    elif hasattr(model, k):
+      if isinstance(getattr(model, k), bool):
+        if v == "false" or v == "":
+          setattr(model, k, False)
+        else:
+          setattr(model, k, True)
+      elif isinstance(getattr(model, k), float) and v != "":
+        setattr(model, k, float(v))
+      elif isinstance(getattr(model, k), int) and v != "":
+        setattr(model, k, int(v))
+      elif isinstance(getattr(model, k), datetime.datetime) and v != "":
+        value = iso8601.parse_date(v)
+        setattr(model, k, value)
+      elif isinstance(getattr(model, k), datetime.date) and v != "":
+        value = datetime.datetime.strptime(v, "%Y-%m-%d")
+        setattr(model, k, datetime.date(value.year, value.month, value.day))
+      elif isinstance(getattr(model, k), datetime.time) and v != "":
+        value = iso8601.parse_date(v)
+        setattr(model, k, datetime.time(value.hour, value.minute, value.second))
+      else:
+        setattr(model, k, v)
+
+  model.put()

data/rxgen_generators/rx_controller/templates/controller.as.erb

@@ -0,0 +1,38 @@
+package <%= base_package %>.controllers {
+  import <%= base_package %>.models.*;
+  import <%= base_package %>.commands.*;
+
+	import mx.core.Application;		
+  import org.restfulx.Rx;
+  import org.restfulx.controllers.RxApplicationController;
+  import org.restfulx.utils.RxUtils;
+
+  public class <%= command_controller_name %> extends RxApplicationController {
+    private static var controller:<%= command_controller_name %>;
+    
+    public static var models:Array = [<%= model_names %>]; /* Models */
+    
+    public static var commands:Array = [<%= command_names %>]; /* Commands */
+    
+    public function <%= command_controller_name %>(enforcer:SingletonEnforcer, 
+      extraServices:Array, defaultServiceId:int = -1) {
+      super(commands, models, extraServices, defaultServiceId);
+    }
+    
+    public static function get instance():<%= command_controller_name %> {
+      if (controller == null) initialize();
+      return controller;
+    }
+    
+    public static function initialize(extraServices:Array = null, 
+      defaultServiceId:int = -1, airDatabaseName:String = null):void {
+      if (!RxUtils.isEmpty(airDatabaseName)) Rx.airDatabaseName = airDatabaseName;
+      controller = new <%= command_controller_name %>(new SingletonEnforcer, 
+        extraServices, defaultServiceId);
+			Rx.sessionToken = Application.application.parameters.session_token;
+			Rx.authenticityToken = Application.application.parameters.authenticity_token;
+    }
+  }
+}
+
+class SingletonEnforcer {}

data/rxgen_generators/rx_controller/templates/iso8601.py

@@ -0,0 +1,92 @@
+from datetime import datetime, timedelta, tzinfo
+import re
+
+__all__ = ["parse_date", "ParseError"]
+
+# Adapted from http://delete.me.uk/2005/03/iso8601.html
+ISO8601_REGEX = re.compile(r"(?P<year>[0-9]{4})(-(?P<month>[0-9]{1,2})(-(?P<day>[0-9]{1,2})"
+    r"((?P<separator>.)(?P<hour>[0-9]{2}):(?P<minute>[0-9]{2})(:(?P<second>[0-9]{2})(\.(?P<fraction>[0-9]+))?)?"
+    r"(?P<timezone>Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?"
+)
+TIMEZONE_REGEX = re.compile("(?P<prefix>[+-])(?P<hours>[0-9]{2}).(?P<minutes>[0-9]{2})")
+
+class ParseError(Exception):
+    """Raised when there is a problem parsing a date string"""
+
+# Yoinked from python docs
+ZERO = timedelta(0)
+class Utc(tzinfo):
+    """UTC
+    
+    """
+    def utcoffset(self, dt):
+        return ZERO
+
+    def tzname(self, dt):
+        return "UTC"
+
+    def dst(self, dt):
+        return ZERO
+UTC = Utc()
+
+class FixedOffset(tzinfo):
+    """Fixed offset in hours and minutes from UTC
+    
+    """
+    def __init__(self, offset_hours, offset_minutes, name):
+        self.__offset = timedelta(hours=offset_hours, minutes=offset_minutes)
+        self.__name = name
+
+    def utcoffset(self, dt):
+        return self.__offset
+
+    def tzname(self, dt):
+        return self.__name
+
+    def dst(self, dt):
+        return ZERO
+    
+    def __repr__(self):
+        return "<FixedOffset %r>" % self.__name
+
+def parse_timezone(tzstring, default_timezone=UTC):
+    """Parses ISO 8601 time zone specs into tzinfo offsets
+    
+    """
+    if tzstring == "Z":
+        return default_timezone
+    # This isn't strictly correct, but it's common to encounter dates without
+    # timezones so I'll assume the default (which defaults to UTC).
+    # Addresses issue 4.
+    if tzstring is None:
+        return default_timezone
+    m = TIMEZONE_REGEX.match(tzstring)
+    prefix, hours, minutes = m.groups()
+    hours, minutes = int(hours), int(minutes)
+    if prefix == "-":
+        hours = -hours
+        minutes = -minutes
+    return FixedOffset(hours, minutes, tzstring)
+
+def parse_date(datestring, default_timezone=UTC):
+    """Parses ISO 8601 dates into datetime objects
+    
+    The timezone is parsed from the date string. However it is quite common to
+    have dates without a timezone (not strictly correct). In this case the
+    default timezone specified in default_timezone is used. This is UTC by
+    default.
+    """
+    if not isinstance(datestring, basestring):
+        raise ParseError("Expecting a string %r" % datestring)
+    m = ISO8601_REGEX.match(datestring)
+    if not m:
+        raise ParseError("Unable to parse date string %r" % datestring)
+    groups = m.groupdict()
+    tz = parse_timezone(groups["timezone"], default_timezone=default_timezone)
+    if groups["fraction"] is None:
+        groups["fraction"] = 0
+    else:
+        groups["fraction"] = int(float("0.%s" % groups["fraction"]) * 1e6)
+    return datetime(int(groups["year"]), int(groups["month"]), int(groups["day"]),
+        int(groups["hour"]), int(groups["minute"]), int(groups["second"]),
+        int(groups["fraction"]), tz)

data/rxgen_generators/rx_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