dima-restfulx 1.2.0

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

@@ -0,0 +1,42 @@
+package <%= base_package %>.models {
+<% if has_manies.length > 0 -%>
+  import org.restfulx.collections.ModelsCollection;
+<% end -%>
+  import org.restfulx.models.RxModel;
+  
+  [Resource(name="<%= resource_controller_name %>")]
+  [Bindable]
+  public class <%= class_name %> extends RxModel {
+<% if attributes && !attributes.empty? && attributes[0].flex_type != "Boolean" -%>
+    public static const LABEL:String = "<%= attributes[0].flex_name %>";
+<% else -%>
+    public static const LABEL:String = "id";
+<% end -%>
+
+<% for attribute in attributes -%>
+<% if attribute.type == :datetime || attribute.type == :time -%>
+    [DateTime]
+<% end -%>
+    public var <%= attribute.flex_name %>:<%= attribute.flex_type %> = <%= attribute.flex_default %>;
+
+<% end -%>
+<% for model in belongs_tos -%>
+    [BelongsTo]
+    public var <%= model.camelcase(:lower) %>:<%= model.camelcase %>;
+
+<% end -%>
+<% for model in has_ones -%>
+    [HasOne]
+    public var <%= model.camelcase(:lower) %>:<%= model.camelcase %>;
+    
+<% end -%>
+<% for model in has_manies -%>
+    [HasMany]
+    public var <%= model.camelcase(:lower) %>:ModelsCollection;
+    
+<% end -%>
+    public function <%= class_name %>() {
+      super(LABEL);
+    }
+  }
+}

data/generators/rx_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/rx_yaml_scaffold/USAGE

@@ -0,0 +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 "rx_scaffold".
+
+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/generators/rx_yaml_scaffold/rx_yaml_scaffold_generator.rb

@@ -0,0 +1,47 @@
+require 'yaml'
+
+class RxYamlScaffoldGenerator < RubiGen::Base
+  include RestfulX::Configuration
+
+  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(APP_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
+        puts 'running: rx_scaffold ' + line
+        RubiGen::Scripts::Generate.new.run(line.split, :generator => 'rx_scaffold', 
+          :gae => options[:gae])
+        puts 'done ...'
+      end
+      RubiGen::Scripts::Generate.new.run([], :generator => 'rx_main_app', :gae => options[:gae])
+    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/lib/restfulx/active_foo.rb

@@ -0,0 +1,186 @@
+# 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:
+# * Date formats
+# * 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.
+
+# Flex friendly date, datetime formats
+ActiveSupport::CoreExtensions::Date::Conversions::DATE_FORMATS.merge!(:flex_date => "%Y/%m/%d")
+ActiveSupport::CoreExtensions::Time::Conversions::DATE_FORMATS.merge!(:flex_datetime => "%Y/%m/%d %H:%M:%S")
+
+Hash::XML_FORMATTING['date'] = Proc.new { |date| date.to_s(:flex_date) }
+Hash::XML_FORMATTING['datetime'] = Proc.new { |datetime| datetime.to_s(:flex_datetime) }
+
+# ActiveSupport specific patches. More specifically we add +to_fxml+ methods to Array and
+# Hash conversion modules
+module ActiveSupport
+  # refer to: http://api.rubyonrails.org/ for more details
+  module CoreExtensions
+    # Add Flex friendly +to_fxml+ 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
+      end
+    end
+    # Add Flex friendly to_fxml to array conversions
+    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)
+
+          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[:skip_types] ? {} : {:type => "array"})
+          else
+            xml.tag!(root, options[:skip_types] ? {} : {:type => "array"}) {
+              yield xml if block_given?
+              each { |e| e.to_fxml(opts.merge!({ :skip_instruct => true })) }
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+# Flex friendly ActiveRecord patches. More specifically XML serialization improvements.
+# These won't override whatever you may normally do with XML, hence there's Flex specific
+# name for this stuff +to_fxml+.
+module ActiveRecord
+  # refer to: http://api.rubyonrails.org/ for more details
+  module Serialization
+    # Enforces Flex friendly options on XML and delegates processing to standard +to_xml+
+    def to_fxml(options = {}, &block)
+      options.merge!(:dasherize => false)
+      default_except = [:crypted_password, :salt, :remember_token, :remember_token_expires_at]
+      options[:except] = (options[:except] ? options[:except] + default_except : default_except)
+      to_xml(options, &block)
+    end
+  end
+  
+  # Change the xml serializer so that '?'s are stripped from attribute names.
+  # This makes it possible to serialize methods that end in a question mark, like 'valid?' or 'is_true?'
+  class XmlSerializer
+    # Strips '?' from serialized method names
+    def add_tag(attribute)
+      builder.tag!(
+        dasherize? ? attribute.display_name.dasherize : attribute.display_name,
+        attribute.value.to_s,
+        attribute.decorations(!options[:skip_types])
+      )
+    end
+    # Strips '?' from serialized method names
+    class Attribute
+      # Strips '?' from serialized method names
+      def display_name
+        @name.gsub('?','')
+      end
+    end
+  end
+
+  # Add more extensive reporting on errors including field name along with a message
+  # when errors are serialized to XML
+  class Errors
+    # Flex friendly errors
+    def to_fxml(options={})
+      options[:root] ||= "errors"
+      options[:indent] ||= 2
+      options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+      options[:builder].instruct! unless options.delete(:skip_instruct)
+      options[:builder].errors do |e|
+        # The @errors instance variable is a Hash inside the Errors class
+        @errors.each_key do |attr|
+          @errors[attr].each do |msg|
+            next if msg.nil?
+            if attr == "base"
+              options[:builder].error("message" => msg)
+            else
+              fullmsg = @base.class.human_attribute_name(attr) + ' ' + msg
+              options[:builder].error("field" => attr.camelcase(:lower), "message" => fullmsg)
+            end
+          end
+        end
+      end
+    end  
+  end
+end

data/lib/restfulx/active_record_tasks.rb

@@ -0,0 +1,81 @@
+# ActiveRecord specific Rake tasks. Namely, nice little extras such as:
+# - db:mysql:stage
+# - db:refresh
+require File.join(File.dirname(__FILE__), 'tasks')
+
+# stores local copy of the application environment ('production', 'test', etc)
+# so that appropriate values in config/database.yml are used
+APP_ENV = defined?(ENV['RAILS_ENV']) ? ENV['RAILS_ENV'] : ENV['MERB_ENV']
+
+namespace :db do
+  namespace :mysql do
+    namespace :stage do
+      desc "Stage production, test and development databases"
+      task :all do
+        db_names = %w(development test production)
+        admin_password = ENV["ADMINPASS"] || ""
+        db_user_name = ENV["USER"] || "root"
+        db_password = ENV["PASS"] || ""
+        stage_database(db_names, admin_password, db_user_name, db_password)
+      end
+    end
+
+    desc "Stage the database environment for #{APP_ENV}"    
+    task :stage do
+      db_names = [APP_ENV]
+      admin_password = ENV["ADMINPASS"] || ""
+      db_user_name = ENV["USER"] || "root"
+      db_password = ENV["PASS"] || ""
+      stage_database(db_names, admin_password, db_user_name, db_password)
+    end
+  end  
+  
+  # Performs MySQL database set-up based on the username and password
+  # provided. Also updates Rails config/database.yml file with database
+  # username and password
+  def stage_database(db_names, admin_password, db_user_name, db_password)
+    sql_command = ""
+    
+    db_names.each do |name|
+      db_name = ActiveRecord::Base.configurations[name]['database']
+      sql_command += "drop database if exists #{db_name}; " << 
+        "create database #{db_name}; grant all privileges on #{db_name}.* " << 
+        "to #{db_user_name}@localhost identified by \'#{db_password}\';"
+      ActiveRecord::Base.configurations[name]['username'] = db_user_name
+      ActiveRecord::Base.configurations[name]['password'] = db_password
+    end
+
+    if (!File.exist?("#{APP_ROOT}/tmp/stage.sql"))
+      File.open("#{APP_ROOT}/tmp/stage.sql", "w") do |file|
+        file.print sql_command
+      end
+    end
+
+    # back up the original database.yml file just in case
+    File.copy("#{APP_ROOT}/config/database.yml", 
+      "#{APP_ROOT}/config/database.yml.sample") if !File.exist?("#{APP_ROOT}/config/database.yml.sample")
+    
+    dbconfig = File.read("#{APP_ROOT}/config/database.yml")
+    dbconfig.gsub!(/username:.*/, "username: #{db_user_name}")
+    dbconfig.gsub!(/password:.*/, "password: #{db_password}")
+    
+    File.open("#{APP_ROOT}/config/database.yml", "w") do |file|
+      file.print dbconfig
+    end
+
+    if system %(mysql -h localhost -u root --password=#{admin_password} < tmp/stage.sql)
+      puts "Updated config/database.yml and staged the database based on your settings"
+      File.delete("tmp/stage.sql") if File.file?("tmp/stage.sql")
+    else
+      puts "Staging was not performed. Check console for errors. It is possible that 'mysql' executable was not found."
+    end
+  end
+  
+  desc "Drop the database environment for #{APP_ENV} only if it exists"
+  task :drop_if_exists do
+    Rake::Task["db:drop"].invoke rescue nil
+  end
+    
+  desc "Refresh the database environment for #{APP_ENV}"
+  task :refresh => ['db:drop_if_exists', 'db:create', 'db:migrate', 'db:fixtures:load']
+end

data/lib/restfulx/configuration.rb

@@ -0,0 +1,76 @@
+# Interestingly enough there's no way to *just* upper-case or down-case first letter of a given
+# string. Ruby's own +capitalize+ actually downcases all the rest of the characters in the string
+# We patch the class to add our own implementation.
+class String
+  # Upper-case first character of a string leave the rest of the string intact
+  def ucfirst
+    self[0,1].capitalize + self[1..-1]
+  end
+  
+  # Down-case first character of a string leaving the rest of it intact
+  def dcfirst
+    self[0,1].downcase + self[1..-1]
+  end
+end
+
+module RestfulX
+  # Computes necessary configuration options from the environment. This can be used in Rails, Merb
+  # or standalone from the command line.
+  module Configuration
+    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
+    def extract_names(project = nil)
+      if project
+        project_name = project.camelcase.gsub(/\s/, '')
+        project_name_downcase = project_name.downcase
+      else
+        project_name = APP_ROOT.split("/").last.camelcase.gsub(/\s/, '')
+        project_name_downcase = project_name.downcase
+      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
+        controller_name = config['controller-name'] || "ApplicationController"
+      rescue
+        base_folder = base_package = project_name_downcase
+        controller_name = "ApplicationController"
+      end
+      [project_name, project_name_downcase, controller_name, base_package, base_folder]
+    end
+
+    # List files ending in *.as (ActionScript) in a given folder
+    def list_as_files(dir_name)
+      Dir.entries(dir_name).grep(/\.as$/).map { |name| name.sub(/\.as$/, "") }.join(", ")
+    end
+
+    # List files ending in *.mxml in a given folder
+    def list_mxml_files(dir_name)
+      Dir.entries(dir_name).grep(/\.mxml$/).map { |name| name.sub(/\.mxml$/, "") }
+    end
+  end
+end

data/lib/restfulx/datamapper_foo.rb

@@ -0,0 +1,31 @@
+require 'builder'
+require RestfulX::LIB_DIR + 'configuration'
+
+# Flex friendly DataMapper patches, more specifically we just add +to_xml+ on 
+# ValidationErrors class
+module DataMapper
+  # see DataMapper docs for more details
+  module Validate
+    # By default DataMapper validation errors doesn't have +to_xml+ method. This is
+    # actually very useful when dealing with remote stateful clients such as Flex/AIR.
+    class ValidationErrors
+      # Add Flex-friendly +to_xml+ implementation
+      def to_xml
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
+        xml.errors do |e|
+          @errors.each_key do |attribute|
+            @errors[attribute].each do |msg|
+              next if msg.nil?
+              if attribute == "base"
+                e.error("message" => msg)
+              else
+                e.error("field" => attribute.to_s.camelcase(:lower), "message" => msg)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulx/rails/recipes.rb

@@ -0,0 +1,60 @@
+# Adds Capistrano recipes for deploying Flex applications
+#
+# To use these recipes, add the following to your Capfile:
+#
+#   require 'restfulx/rails/recipes'
+require 'find'
+
+Capistrano::Configuration.instance(:must_exist).load do
+  after "deploy:setup", "deploy:flex:setup"
+
+  namespace :db do
+    desc "runs db:refresh in the latest release directory."  
+    task :refresh, :roles => :db do
+       run("cd #{latest_release} && rake db:refresh RAILS_ENV=production")
+    end
+  end
+
+  namespace :deploy do
+    namespace :flex do
+    
+      desc "Creates the flex_files directory in the shared directory"
+      task :setup do
+        flex_dir = File.join(shared_path, 'flex_files')
+        run "#{try_sudo} mkdir -p #{flex_dir} && #{try_sudo} chmod g+w #{flex_dir}"
+      end    
+
+      desc "uploads everything in public/bin up to the server"
+      task :via_dumb_copy, :roles => :app do
+        # the -p flag on mkdir makes intermediate directories (i.e. both /bin and /bin/history), 
+        # and doesn't raise an error if any of the directories already exist.
+        rails_root = Dir.pwd # You have to run cap tasks from RAILS_ROOT anyways
+        base_dir = File.join(rails_root, 'public', 'bin')
+        ec2_base_dir = File.join(shared_path, 'flex_files')
+    
+        Find.find(base_dir) do |file| 
+          filename_without_base_dir = file.sub(base_dir, '')
+          if File.directory?(file)
+            run "mkdir -p #{File.join(ec2_base_dir, filename_without_base_dir)}"
+          else
+            content = File.open(file, 'rb') {|f| f.read}
+            put content, File.join(ec2_base_dir, filename_without_base_dir)
+          end
+        end
+      end
+
+      desc "synchronizes the local and remote public/bin directories using rsync"
+      task :via_rsync, :roles => :app do      
+        username = user || ENV['USER']
+        rails_root = Dir.pwd # You have to run cap tasks from RAILS_ROOT anyways
+        execute_on_servers do |server|
+          `rsync -r -p -v -e \"ssh -i #{ssh_options[:keys]}\" #{File.join(rails_root, 'public', 'bin')}/ #{username}@#{server}:#{File.join(shared_path, 'flex_files')}/`
+        end
+      end
+  
+      task :make_symlink, :roles => :app do
+        run "ln -s #{shared_path}/flex_files #{release_path}/public/bin"
+      end
+    end
+  end
+end

data/lib/restfulx/rails/swf_helper.rb

@@ -0,0 +1,60 @@
+# 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.
+  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 => nil,
+                           :attributes => nil,
+                           :create_div => false, 
+                           :include_authenticity_token => true,
+                           :include_session_token => true
+                          })                       
+    arg_order = [:id, :width, :height, :version, :express_install_swf]
+    js_params = ["'#{swf_url}?#{rails_asset_id(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>
+    # 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
+        params[:flash_vars].reverse_merge!(:authenticity_token => form_authenticity_token)
+      end
+      if params[:include_session_token]
+        params[:flash_vars].reverse_merge!(:session_token => session.session_id)
+      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