restfulx 1.2.5 → 1.3.0

data/lib/restfulx/rx_active_support.rb

@@ -0,0 +1,139 @@
+# There's a number of things that ActiveRecord/ActiveSupport and the rest of the family get
+# ~wrong~ from the point of view of Flex clients.
+#
+# Some of these things are:
+# * XML format (Flex *really* doesn't like dashes in XML messages)
+# * Errors (we need to be more specific and communicate what went wrong *where*) 
+#
+# This is where we try to fix this stuff.
+#
+# Some of the things that are done can be called _monkey_ _patching_ while others can
+# be called extensions. Caveat emptor.
+
+# ActiveSupport specific patches. More specifically we add +to_fxml+ and +to_amf+ methods to Array and
+# Hash conversion modules
+module ActiveSupport::CoreExtensions
+  # Add Flex friendly +to_fxml+ and +to_amf+ to Hash conversions
+  module Hash
+    # refer to: http://api.rubyonrails.org/ for more details
+    module Conversions
+      # Flex friendly XML format, no dashes, etc
+      def to_fxml(options = {})
+        options.merge!(:dasherize => false)
+        options[:indent] ||= 2
+        options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
+                                 :root => "hash" })
+        options[:builder].instruct! unless options.delete(:skip_instruct)
+        dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+        root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
+
+        options[:builder].__send__(:method_missing, root) do
+          each do |key, value|
+            case value
+              when ::Hash
+                value.to_fxml(options.merge({ :root => key, :skip_instruct => true }))
+              when ::Array
+                value.to_fxml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
+              when ::Method, ::Proc
+                # If the Method or Proc takes two arguments, then
+                # pass the suggested child element name.  This is
+                # used if the Method or Proc will be operating over
+                # multiple records and needs to create an containing
+                # element that will contain the objects being
+                # serialized.
+                if 1 == value.arity
+                  value.call(options.merge({ :root => key, :skip_instruct => true }))
+                else
+                  value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
+                end
+              else
+                if value.respond_to?(:to_fxml)
+                  value.to_fxml(options.merge({ :root => key, :skip_instruct => true }))
+                else
+                  type_name = XML_TYPE_NAMES[value.class.name]
+
+                  key = dasherize ? key.to_s.dasherize : key.to_s
+
+                  attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
+                  if value.nil?
+                    attributes[:nil] = true
+                  end
+
+                  options[:builder].tag!(key,
+                    XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
+                    attributes
+                  )
+              end
+            end
+          end
+  
+          yield options[:builder] if block_given?
+        end
+      end
+      
+      # serialize as AMF
+      def to_amf(options = {})
+        RestfulX::AMF.serialize_property(self, {:serializable_names => self.keys, :options => options})
+      end
+    end
+  end
+  
+  module Array
+    # refer to: http://api.rubyonrails.org/ for more details
+    module Conversions
+      # Flex friendly XML format (no dashes, etc)
+      def to_fxml(options = {})
+        raise "Not all elements respond to to_fxml" unless all? { |e| e.respond_to? :to_fxml }
+
+        options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+        options[:children] ||= options[:root].singularize
+        options[:indent]   ||= 2
+        options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
+        options.merge!(:dasherize => false)
+        
+        options[:attributes] ||= {}
+        options[:attributes].merge!(:type => "array")
+
+        root     = options.delete(:root).to_s
+        children = options.delete(:children)
+
+        if !options.has_key?(:dasherize) || options[:dasherize]
+          root = root.dasherize
+        end
+
+        options[:builder].instruct! unless options.delete(:skip_instruct)
+
+        opts = options.merge({ :root => children })
+
+        xml = options[:builder]
+        if empty?
+          xml.tag!(root, options[:attributes])
+        else
+          xml.tag!(root, options[:attributes]) {
+            yield xml if block_given?
+            each { |e| e.to_fxml(opts.merge!({ :skip_instruct => true })) }
+          }
+        end
+      end
+    
+      # Serialize as AMF
+      def to_amf(options = {})
+        raise "Not all elements respond to to_amf" unless all? { |e| e.respond_to? :to_amf }
+        
+        options[:attributes] ||= {}
+        options[:serializer] ||= RestfulX::AMF::RxAMFSerializer.new
+        options[:serializer].serialize_typed_array(self, options).to_s
+     end
+    end
+  end
+end
+
+class Array
+  alias_method :to_json_original, :to_json
+  
+  # Serialize array as RestfulX friendly JSON (with metadata)
+  def to_json(options = {})
+    attributes = options.delete(:attributes)
+    return (attributes.nil?) ? to_json_original(options) : "[{#{'metadata'.inspect}: #{attributes.to_json}},#{to_json_original(options)[1..-1]}]"
+  end
+end

data/lib/restfulx/{datamapper_foo.rb → rx_datamapper.rb}

@@ -2,11 +2,9 @@
 # ValidationErrors class
 require 'dm-serializer/common'
 require 'dm-serializer/xml_serializers'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'restfulx') if !defined?(RestfulX)
 
 # RestfulX datamapper patches
 module DataMapper
-  
   # Monkey patches dm-serialization to_json method to add ruby_class: YourClass
   # to all serialized objects
   module Serialize

data/lib/restfulx/{rails/schema_to_yaml.rb → schema_to_rx_yaml.rb}

@@ -1,10 +1,92 @@
 # Used for analyzing your schema and exporting a model.yml file for Rx
 # Provides facilities to convert an existing Rails application schema.rb file to 
 # RestfulX model.yml file
-module SchemaToYaml
-  # SchemaToYaml.schema_to_yaml
+module SchemaToRxYaml
+  module Settings
+    APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : File.expand_path(".")
+    
+    class Config
+      class << self
+        def configure
+          yield self
+        end
+
+        def settings_file
+          @settings_file ||= :restfulx
+        end
+        attr_writer :settings_file
+      end
+    end
+    
+    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?(RestfulX::Configuration::APP_ROOT) ? "#{RestfulX::Configuration::APP_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
+    
+  # SchemaToRxYaml.schema_to_rx_yaml
   #  - set of commands that introspects your database and formats your model.yml for export
-  def self.schema_to_yaml
+  def self.schema_to_rx_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 - 
@@ -83,6 +165,7 @@ module SchemaToYaml
       # Appends belong_to's to schema
       if belong_tos.size > 0
         belong_tos = belong_tos.delete_if {|x| x == "#{@polymorphic}, " }
+        break if belong_tos.size == 0   # fixing to get around nil error when you only have one polymorphic belong_to
         last_in_array_fix = belong_tos.last
         last_in_array_fix = last_in_array_fix.gsub(', ','')
         belong_tos.pop
@@ -93,7 +176,7 @@ module SchemaToYaml
       # 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(', ','')
+        last_in_array_fix = last_in_array_fix.gsub(', ','') unless last_in_array_fix.nil?
         has_manies.pop
         has_manies << last_in_array_fix
         schema << " - has_many: [#{has_manies}]\n" 
@@ -105,6 +188,6 @@ module SchemaToYaml
     # 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" 
+    puts "model.yml created at db/model.yml" 
   end
 end

data/lib/restfulx/swf_helper.rb

@@ -0,0 +1,61 @@
+# Adds a little helper to make it easier empbedding SWFs in ERB templates.
+module RestfulX
+  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.
+    def swfobject(swf_url, params = {})
+      params.reverse_merge!({:width => '100%',
+                             :height => '100%',
+                             :id => 'flashContent',
+                             :version => '9.0.0',
+                             :express_install_swf => '/expressInstall.swf',
+                             :flash_vars => nil,
+                             :params => { },
+                             :attributes => { },
+                             :create_div => false, 
+                             :include_authenticity_token => true,
+                             :include_session_token => true
+                            })                       
+      arg_order = [:id, :width, :height, :version, :express_install_swf]
+      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
+      # If it's a string representing the name of a Javascript variable, then you need to add them yourself 
+      # like this:
+      # <script>
+      #   ... other code that defines flashVars and sets some of its parameters
+      #   flashVars['authenticity_token'] = <%= form_authenticity_token -%>
+      #   flashVars['session_token'] = <%= session.session_id -%>
+      # </script>
+      params[:flash_vars] ||= {}
+      if params[:flash_vars].is_a?(Hash)
+        if params[:include_authenticity_token] && ::ActionController::Base.allow_forgery_protection
+          params[:flash_vars].reverse_merge!(:authenticity_token => form_authenticity_token)
+        end
+        if params[:include_session_token]
+          if RAILS_GEM_VERSION =~ /^2.3/
+            params[:flash_vars].reverse_merge!(:session_token => request.session_options[:id])
+          else
+            params[:flash_vars].reverse_merge!(:session_token => session.session_id)
+          end
+        end        
+      end          
+    
+      js_params += [params[:flash_vars], params[:params], params[:attributes]].collect do |hash_or_string|
+        if hash_or_string.is_a?(Hash)
+          hash_or_string.to_json
+        else # If it's not a hash, then it should be a string giving the name of the Javascript variable to use
+          hash_or_string
+        end
+      end.compact
+
+      swf_tag = javascript_tag do 
+        "swfobject.embedSWF(#{js_params.join(',')})"
+      end 
+      swf_tag += content_tag(:div, nil, :id => params[:id]) if params[:create_div]    
+      swf_tag
+    end
+  end
+end

data/lib/restfulx/tasks.rb

@@ -1,8 +1,9 @@
 # Rake tasks for building RestfulX-based Flex and AIR applications
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 require 'rake'
 require 'rexml/document'
 require 'activesupport'
-require File.join(File.dirname(__FILE__), 'configuration')
+require 'configuration'
 
 include RestfulX::Configuration
 
@@ -33,7 +34,8 @@ namespace :rx do
       
     libs = Dir.glob(File.join(APP_ROOT, 'lib', '*.swc')).map {|lib| lib.gsub(' ', '\ ')}
       
-    additional_compiler_args = get_app_properties().elements["actionScriptProperties"].elements["compiler"].attributes["additionalCompilerArguments"]
+    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(' ', '\ ')}"
@@ -98,7 +100,7 @@ namespace :rx do
   
   namespace :air do
     desc "Build project swf file as an AIR application and move it into bin-debug folder"
-    task :build do   
+    task :build do
       compile_application(:destination => 'bin-debug', :opts => '+configname=air')
     end
     

data/rails_generators/rx_config/rx_config_generator.rb

@@ -93,7 +93,7 @@ class RxConfigGenerator < Rails::Generator::Base
       
       m.directory "#{flex_root}/#{base_folder}/views/generated"
       
-      framework_release = RestfulX::FRAMEWORK_VERSION
+      framework_release = RestfulX::VERSION
       framework_distribution_url = "http://restfulx.github.com/releases/restfulx-#{framework_release}.swc"
       framework_destination_file = "lib/restfulx-#{framework_release}.swc"
       
@@ -119,7 +119,7 @@ class RxConfigGenerator < Rails::Generator::Base
       
       m.template 'index.erb', 'app/views/flex/index.html.erb'
       
-      m.file 'routes.erb', 'config/routes.rb', :collision => :ask
+      m.file 'routes.erb', 'config/routes.rb', :collision => options[:collision]
       
       FileUtils.rm 'public/index.html' if File.exist?('public/index.html')
               

data/rails_generators/rx_config/templates/mainapp.mxml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <mx:<%= application_tag %> xmlns:mx="http://www.adobe.com/2006/mxml"
-  xmlns:generated="<%= base_package %>.components.generated.*"
+  xmlns:generated="<%= base_package %>.views.generated.*"
   paddingBottom="8" paddingLeft="8" paddingRight="8" paddingTop="8"
   layout="horizontal" styleName="plain" initialize="init()">
   <mx:Script>

data/rails_generators/rx_config/templates/restfulx.erb

@@ -30,8 +30,10 @@ class FlexNestedAttributeMiddleware
     if req && req.path_info =~ /\.fxml$/
       if req.put? || req.post? || req.delete?
         req.params.each do |key,value|
-          value.select { |k,v| k =~ /\_attributes$/ }.each do |match|
-            env['rack.request.form_hash'][key][match[0]] = ActiveSupport::JSON.decode(match[1])
+          if value.respond_to? :select
+            value.select { |k,v| k =~ /\_attributes$/ }.each do |match|
+              env['rack.request.form_hash'][key][match[0]] = ActiveSupport::JSON.decode(match[1])
+            end
           end
         end
       end
@@ -72,4 +74,4 @@ ActionController::Base.allow_forgery_protection = false
 <% if distributed -%>
 # If we are in distributed mode we need to make sure that the RestfulX::UUIDHelper is loaded
 require "restfulx/active_record_uuid_helper"
-<% end -%>
+<% end -%>

data/rails_generators/rx_main_app/rx_main_app_generator.rb

@@ -4,7 +4,7 @@ module Rails
   module Generator
     module Commands
       class Create
-        include SchemaToYaml
+        include SchemaToRxYaml
       end
     end
   end
@@ -50,7 +50,7 @@ class RxMainAppGenerator < Rails::Generator::Base
 
   def manifest
     record do |m|      
-      m.template 'mainapp.mxml', File.join("#{flex_root}", "#{flex_project_name}.mxml")
+      m.template 'mainapp.mxml', File.join("#{flex_root}", "#{flex_project_name}.mxml"), :collision => options[:collision]
     end
   end
 

data/rails_generators/rx_scaffold/rx_scaffold_generator.rb

@@ -63,7 +63,7 @@ module Rails
     end
     module Commands
       class Create
-        include SchemaToYaml
+        include SchemaToRxYaml
       end
     end
   end
@@ -71,7 +71,7 @@ end
 
 class RxScaffoldGenerator < Rails::Generator::NamedBase
   include RestfulX::Configuration
-  include SchemaToYaml
+  include SchemaToRxYaml
   
   attr_reader   :project_name, 
                 :flex_project_name, 
@@ -129,22 +129,22 @@ class RxScaffoldGenerator < Rails::Generator::NamedBase
       unless options[:flex_view_only]
         m.template 'model.as.erb',
           File.join("#{@flex_root}", base_folder, "models", "#{@class_name}.as"), 
-          :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
+          :assigns => { :resource_controller_name => "#{file_name.pluralize}" }, :collision => options[:collision]
           
         m.template "controllers/#{RxSettings.controller_pattern}.rb.erb", File.join("app/controllers", 
-          controller_class_path, "#{controller_file_name}_controller.rb") unless options[:flex_only]
+          controller_class_path, "#{controller_file_name}_controller.rb"), :collision => options[:collision] unless options[:flex_only]
         
-        m.template 'model.rb.erb', File.join("app", "models", "#{file_name}.rb") unless options[:flex_only]
+        m.template 'model.rb.erb', File.join("app", "models", "#{file_name}.rb"), :collision => options[:collision] unless options[:flex_only]
       end
         
       if @layout.size > 0
         m.template "layouts/#{@layout}.erb",
           File.join("#{@flex_root}", base_folder, "views", "generated", "#{@class_name}Box.mxml"), 
-          :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
+          :assigns => { :resource_controller_name => "#{file_name.pluralize}" }, :collision => options[:collision]
       else
         m.template "layouts/#{RxSettings.layouts.default}.erb",
           File.join("#{@flex_root}", base_folder, "views", "generated", "#{@class_name}Box.mxml"), 
-          :assigns => { :resource_controller_name => "#{file_name.pluralize}" }
+          :assigns => { :resource_controller_name => "#{file_name.pluralize}" }, :collision => options[:collision]
       end
 
       unless options[:skip_fixture]