restfulx 1.2.1 → 1.2.2

data/lib/restfulx/configuration.rb

@@ -13,54 +13,42 @@ class String
   end
 end
 
+# Primary RestfulX configuration options
 module RestfulX
   # Computes necessary configuration options from the environment. This can be used in Rails, Merb
   # or standalone from the command line.
   module Configuration
+    # We try to figure out the application root using a number of possible options
     APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : defined?(Merb) ? Merb.root : File.expand_path(".")
 
-    # Extract project, package, controller names from the environment. This will respect
-    # config/restfulx.yml if it exists, you can override all of the defaults there. The defaults are:
-    # - *base-package* same as project name downcased
-    # - *controller-name* 'ApplicationController'
-    #
-    # Here's a sample restfulx.yml file:
-    #
-    # RestfulX code generation configuration options
-    # 
-    # By default flex models, commands, controllers and components are genearated into
-    # app/flex/<your rails project name> folder. If you'd like to customize the target folder 
-    # (to say append a "com" package before your rails project name) uncomment the line below
-    # base-package must follow the usual flex package notation (a string separated by ".")
-    # 
-    # base-package: com.pomodo
-    # 
-    # Main RestfulX controller is typically named AppicationController. This controller is created in 
-    # <base-package>.controllers folder. You can customize the name by uncommenting the following line 
-    # and changing the controller name.
-    # 
-    # controller-name: ApplicationController
+    # Extract project, package, controller name, etc from the environment. This will respect
+    # config/restfulx.yml if it exists, you can override all of the defaults there.
     def extract_names(project = nil)
       if project
-        project_name = project.camelcase.gsub(/\s/, '')
-        project_name_downcase = project_name.downcase
+        project_name = project.downcase.gsub(/\W/, '')
+        flex_project_name = project_name.camelize
       else
-        project_name = APP_ROOT.split("/").last.camelcase.gsub(/\s/, '')
-        project_name_downcase = project_name.downcase
+        project_name = APP_ROOT.split("/").last.gsub(/\W/, '')
+        flex_project_name = project_name.camelize
       end
-      
+            
       # give a chance to override the settings via restfulx.yml
       begin      
         config = YAML.load(File.open("#{APP_ROOT}/config/restfulx.yml"))
-        base_package = config['base-package'] || project_name_downcase
-        base_folder = base_package.gsub('.', '/').gsub(/\s/, '')
-        project_name = config['project-name'].camelcase.gsub(/\s/, '') || project_name
+        base_package = config['base-package'] || flex_project_name.downcase
+        base_folder = base_package.gsub('.', '/')
+        project_name = config['project-name'].downcase.gsub(/\W/, '') || project_name
+        flex_project_name = project_name.camelize
         controller_name = config['controller-name'] || "ApplicationController"
+        flex_root = config['flex-root'] || "app/flex"
+        distributed = config['distributed'] || false
       rescue
-        base_folder = base_package = project_name_downcase
+        base_folder = base_package = flex_project_name.downcase
         controller_name = "ApplicationController"
+        flex_root = "app/flex"
+        distributed = false
       end
-      [project_name, project_name_downcase, controller_name, base_package, base_folder]
+      [project_name, flex_project_name, controller_name, base_package, base_folder, flex_root, distributed]
     end
 
     # List files ending in *.as (ActionScript) in a given folder

data/lib/restfulx/rails/schema_to_yaml/extensions/enumerable.rb

@@ -0,0 +1,8 @@
+# Enumerable extensions
+module Enumerable
+  # Helps you find duplicates
+  # used in schema_to_yaml.rb for cleanup
+  def dups
+    inject({}) {|h,v| h[v]=h[v].to_i+1; h}.reject{|k,v| v==1}.keys
+  end
+end

data/lib/restfulx/rails/schema_to_yaml/settings/config.rb

@@ -0,0 +1,17 @@
+# SchemaToYaml settings
+module SchemaToYaml
+  module Settings
+    class Config
+      class << self
+        def configure
+          yield self
+        end
+
+        def settings_file
+          @settings_file ||= :restfulx
+        end
+        attr_writer :settings_file
+      end
+    end
+  end
+end

data/lib/restfulx/rails/schema_to_yaml/settings/core.rb

@@ -0,0 +1,70 @@
+# Inspired from http://settingslogic.rubyforge.org/
+# Used to read in settings from restfulx.yml for use in code generation
+module SchemaToYaml
+  module Settings
+    class Core
+      class << self
+        def name
+          instance._settings.key?("name") ? instance.name : super
+        end
+        
+        def reset!
+          @instance = nil
+        end
+        
+      private
+        def instance
+          @instance ||= new
+        end
+        
+        def method_missing(name, *args, &block)
+          instance.send(name, *args, &block)
+        end
+      end
+      
+      attr_accessor :_settings
+      
+      def initialize(name_or_hash = Config.settings_file)
+        case name_or_hash
+        when Hash
+          self._settings = name_or_hash
+        when String, Symbol
+          root_path = defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/config/" : ""
+          file_path = name_or_hash.is_a?(Symbol) ? "#{root_path}#{name_or_hash}.yml" : name_or_hash
+          self._settings = YAML.load(ERB.new(File.read(file_path)).result)
+          self._settings = _settings[RAILS_ENV] if defined?(RAILS_ENV)
+        else
+          raise ArgumentError.new("Your settings must be a hash, 
+            a symbol representing the name of the .yml file in your config directory,
+            or a string representing the abosolute path to your settings file.")
+        end
+        define_settings!
+      end
+      
+    private
+      def method_missing(name, *args, &block)
+        raise NoMethodError.new("no configuration was specified for #{name}")
+      end
+      
+      def define_settings!
+        return if _settings.nil?
+        _settings.each do |key, value|
+          case value
+          when Hash
+            instance_eval <<-"end_eval", __FILE__, __LINE__
+              def #{key}
+                @#{key} ||= self.class.new(_settings["#{key}"])
+              end
+            end_eval
+          else
+            instance_eval <<-"end_eval", __FILE__, __LINE__
+              def #{key}
+                @#{key} ||= _settings["#{key}"]
+              end
+            end_eval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulx/rails/schema_to_yaml.rb

@@ -0,0 +1,121 @@
+# Used for analyzing your schema and exporting a model.yml file for Rx
+require "yaml" 
+require "erb" 
+require File.dirname(__FILE__) + "/schema_to_yaml/settings/config" 
+require File.dirname(__FILE__) + "/schema_to_yaml/settings/core" 
+
+Dir[File.dirname(__FILE__) + "/schema_to_yaml/extensions/*.rb"].each do |f|
+  require f
+end
+
+# Provides facilities to convert an existing Rails application schema.rb file to 
+# RestfulX model.yml file
+module SchemaToYaml
+  RxSettings = SchemaToYaml::Settings::Core
+
+  # SchemaToYaml.schema_to_yaml
+  #  - set of commands that introspects your database and formats your model.yml for export
+  def self.schema_to_yaml
+    # Iterates through your database, and sets up table_arr with all columns
+    #  - excludes schema_info/schema_migrations/and any other tables you specify in restfulx.yml
+    table_arr = ActiveRecord::Base.connection.tables - 
+      %w(schema_info schema_migrations).map - 
+      RxSettings.ignored.tables[0].split
+      
+    # Excludes columns from each table
+    disregarded_columns = %w(id created_at updated_at) + RxSettings.ignored.fields[0].split
+    
+    # Schema variable is appended to throughout, and is the variable exported to model.yml
+    schema = []
+    
+    # Set up empty array for has_many relationships
+    @array_of_has_manies = []
+
+    # Iterates through each table, and checks for any database field ending in _id
+    table_arr.each do |table|
+      column_arr = ActiveRecord::Base.connection.columns(table)
+      column_arr.each do |col|
+        col_name = col.name.to_s
+        @array_of_has_manies << "#{col_name.gsub(/_id\b/,'')}_#{table}" if col_name[-3,3]=='_id'
+      end
+    end
+
+    table_arr.each do |table|
+      # Set up empty arrays for other associations
+      belong_tos = []
+      has_manies = []
+      polymorphics = []
+
+      # Append table name to schema
+      #  - project:
+      schema << "#{table.singularize}:\n" 
+      column_arr = ActiveRecord::Base.connection.columns(table)
+
+      column_arr.each do |col|
+        col_name = col.name.to_s
+        
+        # Ignore certain columns
+        columns_check = []
+        disregarded_columns.each {|dc| columns_check << col_name.include?(dc) }
+        
+        # Sets up polymorphics array, we'll need to check for duplicates below
+        polymorphics << col_name.gsub('_id','PMCHECK').gsub('_type','PMCHECK')
+
+        # Appends each column under respective table
+        schema << " - #{col_name}: #{col.type}\n" unless columns_check.include?(true)
+
+        # Checks for certain column names
+        #  - If it finds parent_id it sets up a tree_model for generation
+        #  - If it finds _file_size it sets up attachment for generation
+        #  - Sets up belong_tos
+        if col_name == 'parent_id'
+          schema << " - tree_model: [#{col_name.gsub(/_id\b/,'')}]\n" 
+        elsif col_name =~ /_file_size$/
+          schema << " - attachment_field: [#{col_name.gsub(/_file_size$/,'')}]\n" 
+        else
+          belong_tos << col_name.gsub(/_id\b/,', ') if col_name[-3,3]=='_id' && !disregarded_columns.include?(col_name)
+        end
+      end
+
+      # Checks for duplicates in the polymorphics array (used for error checking)
+      if polymorphics.dups.size > 0
+        schema << " - polymorphic: [#{polymorphics.dups.first.gsub('PMCHECK','')}]\n" 
+        @polymorphic = polymorphics.dups.first.gsub('PMCHECK','')
+      end
+
+      # Cleans up has many
+      @array_of_has_manies.each do |hm|
+        sanity_check = hm.gsub(/^#{table.singularize}_/,'')
+        if hm =~ /^#{table.singularize}_/ && table_arr.include?(sanity_check)
+          has_manies << hm.gsub(/^#{table.singularize}_/,'') + ', '
+        end
+      end
+
+      # Appends belong_to's to schema
+      if belong_tos.size > 0
+        belong_tos = belong_tos.delete_if {|x| x == "#{@polymorphic}, " }
+        last_in_array_fix = belong_tos.last
+        last_in_array_fix = last_in_array_fix.gsub(', ','')
+        belong_tos.pop
+        belong_tos << last_in_array_fix
+        schema << " - belongs_to: [#{belong_tos}]\n" 
+      end
+
+      # Appends has_manies' to schema
+      if has_manies.size > 0
+        last_in_array_fix = has_manies.last
+        last_in_array_fix = last_in_array_fix.gsub(', ','')
+        has_manies.pop
+        has_manies << last_in_array_fix
+        schema << " - has_many: [#{has_manies}]\n" 
+      end
+
+      schema << "\n" 
+    end
+
+    # Writes model.yml file
+    yml_file = File.join(RAILS_ROOT, "db", "model.yml")
+    File.open(yml_file, "w") { |f| f << schema.to_s }
+    puts "Model.yml created at db/model.yml" 
+  end
+end

data/lib/restfulx/rails/swf_helper.rb

@@ -1,6 +1,5 @@
 # Adds a little helper to make it easier empbedding SWFs in ERB templates.
 module SWFHelper
-  
   # Creates a swfObject Javascript call.  You must include swfobject.js to use this.
   # See http://code.google.com/p/swfobject/wiki/documentation for full details and documentation
   # of the swfobject js library.
@@ -18,7 +17,7 @@ module SWFHelper
                            :include_session_token => true
                           })                       
     arg_order = [:id, :width, :height, :version, :express_install_swf]
-    js_params = ["'#{swf_url}?#{rails_asset_id(swf_url)}'"]
+    js_params = ["'#{swf_url}'"]
     js_params += arg_order.collect {|arg| "'#{params[arg]}'" }
     
     # Add authenticity_token and the session key to flashVars.  This will only work if flashVars is a Hash or nil
@@ -29,9 +28,6 @@ module SWFHelper
     #   flashVars['authenticity_token'] = <%= form_authenticity_token -%>
     #   flashVars['session_token'] = <%= session.session_id -%>
     # </script>
-    # If you include an authenticity_token parameter in flashVars, 
-    # then the Flex app will add it to Rx.defaultMetadata, so that it will be sent
-    # back up to your Rails app with every request.
     params[:flash_vars] ||= {}
     if params[:flash_vars].is_a?(Hash)
       if params[:include_authenticity_token] && ActionController::Base.allow_forgery_protection
@@ -56,5 +52,4 @@ module SWFHelper
     swf_tag += content_tag(:div, nil, :id => params[:id]) if params[:create_div]    
     swf_tag
   end
-  
 end

data/lib/restfulx/tasks.rb

@@ -2,54 +2,84 @@
 require 'rake'
 require 'ftools'
 require 'rexml/document'
+require 'activesupport'
 require File.join(File.dirname(__FILE__), 'configuration')
 
-APP_ROOT = RestfulX::Configuration::APP_ROOT
+include RestfulX::Configuration
 
 namespace :rx do
-  # Compile the main Flex/AIR application using given executable to the given
-  # destination folder
-  def compile_app(executable, destination, opts = '')
-    app_properties = REXML::Document.new(File.open(File.join(APP_ROOT, ".actionScriptProperties")))
-    app_properties.elements.each("*/applications/application") do |elm|
-      app_path = elm.attributes['path']
-      project_path = File.join(APP_ROOT, "app/flex", app_path)
-      target_project_path = project_path.sub(/.mxml$/, '.swf')
-      target_project_air_descriptor = project_path.sub(/.mxml$/, '-app.xml')
+  # Compile the given Flex/AIR application
+  # The following options are supported:
+  #     :executable => 'mxmlc'
+  #     :application => nil
+  #     :destination => 'public/bin'
+  #     :opts => nil
+  #     :flex_root => 'app/flex'
+  def compile_application(params = {})
+    project_name, flex_project_name, command_controller_name, base_package, base_folder, 
+      flex_root = extract_names()
+    
+    executable = params[:executable] || 'mxmlc'
+    application = params[:application] || get_main_application
+    destination = params[:destination] || 'public/bin'
+    opts = params[:opts] || ''
+    flex_root = params[:flex_root] || flex_root
+    
+    compiler = get_executable(executable)
+    
+    application = get_main_application unless application
+    project_path = File.join(APP_ROOT, flex_root, application)
+    target_project_path = project_path.sub(/.mxml$/, '.swf')
+    target_project_air_descriptor = project_path.sub(/.mxml$/, '-app.xml')
       
-      libs = Dir.glob(File.join(APP_ROOT, 'lib', '*.swc')).map {|lib| lib.gsub(' ', '\ ')}
+    libs = Dir.glob(File.join(APP_ROOT, 'lib', '*.swc')).map {|lib| lib.gsub(' ', '\ ')}
       
-      cmd = "#{executable} #{opts} -library-path+=#{libs.join(',')} " << 
-        "-keep-as3-metadata+=Resource,HasOne,HasMany,BelongsTo,DateTime,Lazy,Ignored #{project_path.gsub(' ', '\ ')}"
-      puts "Compiling #{project_path}"
-      if system(cmd)
-        FileUtils.makedirs File.join(APP_ROOT, destination)
-        puts "Moving #{target_project_path} to " + File.join(APP_ROOT, destination)
-        FileUtils.mv target_project_path, File.join(APP_ROOT, destination), :force => true
-        if File.exist?(target_project_air_descriptor)
-          descriptor = File.read(target_project_air_descriptor)
-          descriptor_name = target_project_air_descriptor.split("/").last
-          app_swf = target_project_path.split("/").last
-          descriptor.gsub!("[This value will be overwritten by Flex Builder in the output app.xml]", 
-            app_swf)
+    additional_compiler_args = get_app_properties().elements["actionScriptProperties"].elements["compiler"].attributes["additionalCompilerArguments"]
+    additional_compiler_args.gsub!("../locale/", "#{APP_ROOT}/app/locale/")
+    
+    cmd = "#{executable} #{opts} -library-path+=#{libs.join(',')} " << additional_compiler_args << " #{project_path.gsub(' ', '\ ')}"
+    puts "Compiling #{project_path}"
+    if system(cmd)
+      FileUtils.makedirs File.join(APP_ROOT, destination)
+      puts "Moving #{target_project_path} to " + File.join(APP_ROOT, destination)
+      FileUtils.mv target_project_path, File.join(APP_ROOT, destination), :force => true
+      if File.exist?(target_project_air_descriptor)
+        descriptor = File.read(target_project_air_descriptor)
+        descriptor_name = target_project_air_descriptor.split("/").last
+        app_swf = target_project_path.split("/").last
+        descriptor.gsub!("[This value will be overwritten by Flex Builder in the output app.xml]", 
+          app_swf)
 
-          File.open("#{APP_ROOT}/#{destination}/#{descriptor_name}", "w") do |file|
-            file.print descriptor
-          end
-          puts "Created #{APP_ROOT}/#{destination}/#{descriptor_name} descriptor."
+        File.open("#{APP_ROOT}/#{destination}/#{descriptor_name}", "w") do |file|
+          file.print descriptor
         end
-        puts 'Done!'
-      else
-        puts "The application was not compiled. Check console for errors. " <<
-          "It is possible that '(a)mxmlc' executable was not found or there are compilation errors."
+        puts "Created #{APP_ROOT}/#{destination}/#{descriptor_name} descriptor."
       end
-    end    
+      puts 'Done!'
+    else
+      puts "The application was not compiled. Check console for errors. " <<
+        "It is possible that '(a)mxmlc' executable was not found or there are compilation errors."
+    end
+  end
+  
+  def run_air_application(params = {})
+    application = params[:application] || get_main_application
+    descriptor = params[:descriptor] || application.sub(/.mxml$/, '-app.xml')
+    destination = params[:destination] || 'bin-debug'
+    
+    puts "Running AIR application with descriptor: #{descriptor}"
+    if !system("#{get_executable('adl')} #{destination}/#{descriptor}")
+      puts "Could not run the application with descriptor: #{destination}/#{descriptor}. Check console for errors."
+    end
   end
   
   # Find what the main application is based on .actionScriptProperties file
   def get_main_application
-    app_properties = REXML::Document.new(File.open(File.join(APP_ROOT, ".actionScriptProperties")))
-    app_properties.root.attributes['mainApplicationPath'].split("/").last
+    get_app_properties().root.attributes['mainApplicationPath'].split("/").last
+  end
+  
+  def get_app_properties
+    REXML::Document.new(File.open(File.join(APP_ROOT, ".actionScriptProperties")))
   end
   
   # Get appropriate executable based on platform
@@ -63,23 +93,19 @@ namespace :rx do
   namespace :flex do
     desc "Build project swf file and move it into public/bin folder"
     task :build do
-      compile_app(get_executable('mxmlc'), 'public/bin')
+      compile_application()
     end
   end
   
   namespace :air do
     desc "Build project swf file as an AIR application and move it into bin-debug folder"
     task :build do   
-      compile_app(get_executable('mxmlc'), 'bin-debug', '+configname=air')
+      compile_application(:destination => 'bin-debug', :opts => '+configname=air')
     end
     
     desc "Run the AIR application (if this project is configured as an AIR project)"
     task :run do
-      target = get_main_application.gsub(/.mxml$/, '-app.xml')
-      puts "Running AIR application with descriptor: #{target}"
-      if !system("#{get_executable('adl')} bin-debug/#{target}")
-        puts "Could not run the application with descriptor: #{target}. Check console for errors."
-      end
+      run_air_application
     end
   end
 end

data/lib/restfulx.rb

@@ -5,17 +5,10 @@
 module RestfulX
 
   # :stopdoc:
-  VERSION = '1.2.1'
-  FRAMEWORK_VERSION = '1.2.1'
+  FRAMEWORK_VERSION = '1.2.2'
   LIB_DIR = File.join(File.dirname(__FILE__), 'restfulx/')
   # :startdoc:
 
-  # Returns the version string for the library.
-  #
-  def self.version
-    VERSION
-  end
-
   # Utility method used to require all files ending in .rb that lie in the
   # directory below this file that has the same name as the filename passed
   # in. Optionally, a specific _directory_ name can be passed in such that
@@ -28,7 +21,6 @@ module RestfulX
 
     Dir.glob(search_me).sort.each {|rb| require rb}
   end
-
 end
 
 require RestfulX::LIB_DIR + 'configuration'
@@ -54,9 +46,10 @@ elsif defined?(ActionController::Base)
   # if we are not running in Merb, try to hook up Rails
   Mime::Type.register_alias "application/xml", :fxml
   
-  ['active_foo', 'rails/swf_helper'].each { |lib| require RestfulX::LIB_DIR + lib }
+  ['active_foo', 'rails/swf_helper', 'rails/schema_to_yaml'].each { |lib| require RestfulX::LIB_DIR + lib }
 
-  ActionView::Base.send :include, SWFHelper unless ActionView::Base.included_modules.include?(SWFHelper)  
+  ActionView::Base.send :include, SWFHelper unless ActionView::Base.included_modules.include?(SWFHelper)
+  ActiveRecord::Migration.send :include, SchemaToYaml
 
   # We mess with default +render+ implementation a bit to add support for expressions
   # such as format.fxml { render :fxml => @foo }
@@ -78,24 +71,6 @@ elsif defined?(ActionController::Base)
       end
     end
   end
-
-  # It is possible to pass metadata with any RestfulX model. This module adds support for
-  # extracting that metadata into the standard params hash.
-  module RxController
-    private
-
-    # Extract any keys named _metadata from the models in the params hash
-    # and put them in the root of the params hash.
-    def extract_metadata_from_params
-      metadata = {}
-      metadata.merge!(params.delete('_metadata')) if params.has_key?('_metadata')
-      params.each do |k, v|
-        next unless v.respond_to?(:has_key?) and v.has_key?('_metadata')
-        metadata.merge!(v.delete('_metadata'))
-      end
-      params.merge!(metadata) unless metadata.empty?
-    end  
-  end
   
   module ActiveRecord
     # ActiveRecord named scopes are computed *before* restfulx gem gets loaded
@@ -108,12 +83,6 @@ elsif defined?(ActionController::Base)
       end
     end
   end
-
-  ActionController::Base.send :include, RxController  
-  ActionController::Base.send :prepend_before_filter, :extract_metadata_from_params  
-
-  # temporarily disable forgery protection site-wise
-  ActionController::Base.allow_forgery_protection = false
 elsif defined?(DataMapper)
   require RestfulX::LIB_DIR + 'datamapper_foo'
 elsif defined?(ActiveRecord::Base)

data/rails_generators/rx_config/USAGE

@@ -14,5 +14,6 @@ Examples:
                                   # folder
     `./script/generate rx_config -a` # as above but generates an AIR app
                                      # and configuration
-    `./script/generate rx_config -s` # generates Flex app but does not fetch
+    `./script/generate rx_config --skip-framework` # generates Flex app 
+                                     # but does not fetch
                                      # the RestfulX framework SWC.