ruboss_on_ruby 1.0.1

data/lib/ruboss_on_ruby.rb

@@ -0,0 +1,64 @@
+#$:.unshift(File.dirname(__FILE__)) unless
+#  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+# Merb specific handling
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  Merb::BootLoader.before_app_loads do
+    Merb.add_mime_type(:fxml,  :to_fxml,  %w[application/xml text/xml application/x-xml], :charset => "utf-8")
+
+    require 'ruboss_on_ruby/version'
+    require 'ruboss_on_ruby/configuration'
+    require 'ruboss_on_ruby/active_foo' if defined?(ActiveRecord::Base)
+  end
+  
+  # TODO: can we find out if use_orm :activerecord is on and only then load active record specific tasks?
+  Merb::Plugins.add_rakefiles "ruboss_on_ruby/tasks", "ruboss_on_ruby/active_record_tasks"  
+elsif defined?(ActionController::Base)
+  # if we are not running in Merb, we've got to be running in Rails
+  Mime::Type.register_alias "application/xml", :fxml
+
+  require 'ruboss_on_ruby/version'
+  require 'ruboss_on_ruby/configuration'
+  require 'ruboss_on_ruby/active_foo'
+
+  module ActionController
+    class Base
+      alias_method :old_render, :render
+
+      # so that we can have handling for :fxml option and write code like
+      # format.fxml  { render :fxml => @projects }
+      def render(options = nil, extra_options = {}, &block)
+        if options and options[:fxml]
+          xml = options[:fxml]
+          response.content_type ||= Mime::XML
+          render_for_text(xml.respond_to?(:to_fxml) ? xml.to_fxml : xml, options[:status])
+        else
+          old_render(options, extra_options, &block)
+        end
+      end
+    end
+  end
+
+  module RubossOnRubyController
+    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
+
+  # temporarily disable forgery protection site-wise
+  ActionController::Base.allow_forgery_protection = false
+
+  ActionController::Base.send :include, RubossOnRubyController
+  ActionController::Base.send :prepend_before_filter, :extract_metadata_from_params
+end

data/lib/ruboss_on_ruby/active_foo.rb

@@ -0,0 +1,127 @@
+#ActiveRecord+ActiveSupport specific patches
+
+# 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) }
+
+class ClassyEmptyArray < Array
+  def initialize(class_name)
+    @class_name = class_name
+  end
+  def to_fxml(*args) # You need the *args so that it doesn't fail if there are :include or :methods params
+    empty? ? "<#{@class_name} type=\"array\"/>" : super.to_fxml
+  end
+end
+
+module ActiveSupport
+  module CoreExtensions
+    module Hash
+      module Conversions
+        def to_fxml(options = {})
+          options.merge!(:dasherize => false)
+          to_xml(options)
+        end
+      end
+    end
+    module Array
+      module Conversions
+        def to_fxml(options = {})
+          options.merge!(:dasherize => false)
+          to_xml(options)
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  # Flex friendly XML serialization patches
+  class Base
+    class << self
+      alias_method :old_find, :find
+
+      def find(*args)
+        result = old_find(*args)
+        if result.class == Array and result.empty?
+          result = ClassyEmptyArray.new(self.class_name.tableize)
+        end
+        result
+      end
+
+      # TODO: this doesn't work with hash based to_fxml(:include) options, only array based
+      def default_fxml_methods(*args)
+        methods = *args.dup
+        module_eval <<-END 
+            def self.default_fxml_methods_array
+              return [#{methods.inspect}].flatten
+            end
+          END
+      end
+      
+      def default_fxml_includes(*args)
+        includes = *args.dup
+        module_eval <<-END
+          def self.default_fxml_include_params
+            return [#{includes.inspect}].flatten
+          end
+        END
+      end
+    end
+  end
+
+  module Serialization
+    def to_fxml(options = {})
+      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)
+      options[:methods] = [options[:methods] || []].flatten + self.class.default_fxml_methods_array if self.class.respond_to?(:default_fxml_methods_array)      
+      options[:include] = [options[:include] || []].flatten + self.class.default_fxml_include_params if self.class.respond_to?(:default_fxml_include_params)
+      to_xml(options)
+    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
+    def add_tag(attribute)
+      builder.tag!(
+        dasherize? ? attribute.display_name.dasherize : attribute.display_name,
+        attribute.value.to_s,
+        attribute.decorations(!options[:skip_types])
+      )
+    end    
+    class Attribute
+      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
+    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/ruboss_on_ruby/active_record_tasks.rb

@@ -0,0 +1,75 @@
+require 'ruboss_on_ruby/tasks'
+
+# these tasks are active record specific
+
+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  
+    
+  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/ruboss_on_ruby/configuration.rb

@@ -0,0 +1,38 @@
+class String
+  def capitalize_without_downcasing
+    self[0,1].capitalize + self[1..-1]
+  end
+  def downcase_first_letter
+    self[0,1].downcase + self[1..-1]
+  end
+end
+
+module RubossOnRuby
+  module Configuration
+    APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : Merb.root
+
+    def extract_names
+      project_name = APP_ROOT.split("/").last.camelcase
+      project_name_downcase = project_name.downcase
+
+      begin      
+        config = YAML.load(File.open("#{APP_ROOT}/config/ruboss.yml"))
+        base_package = config['base-package'] || project_name_downcase
+        base_folder = base_package.gsub('.', '/')
+        controller_name = config['controller-name'] || "#{project_name}Controller"
+      rescue
+        base_folder = base_package = project_name_downcase
+        controller_name = "#{project_name}Controller"
+      end
+      [project_name, project_name_downcase, controller_name, base_package, base_folder]
+    end
+
+    def list_as_files(dir_name)
+      Dir.entries(dir_name).grep(/\.as$/).map { |name| name.sub(/\.as$/, "") }.join(", ")
+    end
+
+    def list_mxml_files(dir_name)
+      Dir.entries(dir_name).grep(/\.mxml$/).map { |name| name.sub(/\.mxml$/, "") }
+    end
+  end
+end

data/lib/ruboss_on_ruby/tasks.rb

@@ -0,0 +1,74 @@
+require 'rake'
+require 'ftools'
+require 'rexml/document'
+require 'ruboss_on_ruby/version'
+require 'ruboss_on_ruby/configuration'
+
+APP_ROOT = RubossOnRuby::Configuration::APP_ROOT
+
+namespace :ruboss do
+  def compile_app(executable, destination)
+    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')
+      
+      libs = Dir.glob(File.join(APP_ROOT, 'lib', '*.swc'))
+      
+      cmd = "#{executable} -library-path+=#{libs.join(',')} " << 
+        "-keep-as3-metadata+=Resource,HasOne,HasMany,BelongsTo,DateTime,Lazy,Ignored #{project_path}"
+      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."
+        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    
+  end
+  
+  def get_main_application
+    app_properties = REXML::Document.new(File.open(File.join(APP_ROOT, ".actionScriptProperties")))
+    app_properties.root.attributes['mainApplicationPath'].split("/").last
+  end
+  
+  namespace :flex do
+    desc "Build project swf file and move it into public/bin folder"
+    task :build do
+      compile_app('mxmlc', 'public/bin')
+    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('amxmlc', 'bin-debug')
+    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("adl bin-debug/#{target}")
+        puts "Could not run the application with descriptor: #{target}. Check console for errors."
+      end
+    end
+  end
+end

data/lib/ruboss_on_ruby/version.rb

@@ -0,0 +1,11 @@
+module RubossOnRuby #:nodoc:
+  RUBOSS_FRAMEWORK_VERSION = 'latest-dima'
+
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/merb_generators/ruboss_config/USAGE

@@ -0,0 +1,18 @@
+Description:
+    Generates the primary Ruboss directory structure, sets up Flex Builder
+    specific descriptor files and options fetches the latest published 
+    Ruboss Framework SWC file.
+    
+    You can generate Flex Builder configuration for either *pure* Flex
+    project or an AIR project. To generate AIR configuration pass the -a
+    (--air) option to the generator.
+
+Examples:
+    `merb-gen ruboss_config` # generates project structure and a 
+                                # default Flex app configuration. Fetches 
+                                # latest ruboss framework SWC to "lib" 
+                                # folder
+    `merb-gen ruboss_config -a` # as above but generates an AIR app
+                                # and configuration
+    `merb-gen ruboss_config -s` # generates Flex app but does not fetch
+                                # the ruboss framework SWC.

data/merb_generators/ruboss_config/ruboss_config_generator.rb

@@ -0,0 +1,135 @@
+################################################################################
+# Copyright 2008, Ruboss Technology Corporation.
+#
+# This software is dual-licensed under both the terms of the Ruboss Commercial
+# License v1 (RCL v1) as published by Ruboss Technology Corporation and under
+# the terms of the GNU General Public License v3 (GPL v3) as published by the
+# Free Software Foundation.
+#
+# Both the RCL v1 (rcl-1.0.txt) and the GPL v3 (gpl-3.0.txt) are included in
+# the source code. If you have purchased a commercial license then only the
+# RCL v1 applies; otherwise, only the GPL v3 applies. To learn more or to buy a
+# commercial license, please go to http://ruboss.com.
+################################################################################
+require 'open-uri'
+require 'fileutils'
+require 'ruboss_on_ruby/version'
+require 'ruboss_on_ruby/configuration'
+
+class RubossConfigGenerator < Merb::GeneratorBase
+  include RubossOnRuby::Configuration
+
+  default_options :main_only => false, :air_config => false, :skip_framework => false
+    
+  attr_reader :project_name, 
+              :flex_project_name, 
+              :base_package, 
+              :base_folder, 
+              :command_controller_name, 
+              :component_names, 
+              :application_tag,
+              :use_air
+
+  def initialize(runtime_args, runtime_options = {})
+    runtime_args.push ""
+    super
+    
+    @project_name, @flex_project_name, @command_controller_name, @base_package, @base_folder = extract_names
+    
+    # if we updating main file only we probably want to maintain the type of project it is
+    if options[:main_only]
+      project_file_name = APP_ROOT + '/.project'
+      if File.exist?(project_file_name)
+        puts "Cannot combine -m (--main-app) and -a (--air) flags at the same time for an existing application.\n" << 
+          'If you want to convert to AIR, remove -m flag.' if options[:air_config]
+        @use_air = true if File.read(project_file_name) =~/com.adobe.flexbuilder.apollo.apollobuilder/m
+      else
+        puts "Flex Builder project file doesn't exist. You should run 'ruboss_config' with -a (--air) option or " <<
+          "no arguments first to generate primary project structure."
+        exit 0;
+      end
+    else
+      @use_air = options[:air_config]
+    end
+                
+    if @use_air
+      @application_tag = 'WindowedApplication'
+    else
+      @application_tag = 'Application'
+    end
+        
+    @component_names = []
+    if File.exists?("app/flex/#{base_folder}/components/generated")
+      @component_names = list_mxml_files("app/flex/#{base_folder}/components/generated")
+    end
+  end
+
+  def manifest
+    record do |m|
+      if !options[:main_only]
+        m.directory 'public/bin'
+        m.directory 'public/javascripts'
+        m.directory 'schema'
+        
+        m.file 'flex.properties', '.flexProperties'
+        if @use_air
+          m.template 'actionscriptair.properties', '.actionScriptProperties'
+          m.template 'projectair.properties', '.project'
+        else
+          m.template 'actionscript.properties', '.actionScriptProperties'
+          m.template 'project.properties', '.project'
+        end
+  
+        m.directory 'html-template/history'      
+        %w(index.template.html AC_OETags.js playerProductInstall.swf).each do |file|
+          m.file "html-template/#{file}", "html-template/#{file}"
+        end
+        
+        %w(history.css history.js historyFrame.html).each do |file|
+          m.file "html-template/history/#{file}", "html-template/history/#{file}"
+        end
+        
+        %w(components controllers commands models events).each do |dir|
+          m.directory "app/flex/#{base_folder}/#{dir}"
+        end
+        
+        m.directory "app/flex/#{base_folder}/components/generated"
+                
+        framework_release = RubossOnRuby::RUBOSS_FRAMEWORK_VERSION
+        framework_distribution_url = "http://ruboss.com/releases/ruboss-#{framework_release}.swc"
+        framework_destination_file = "lib/ruboss-#{framework_release}.swc"
+        
+        if !options[:skip_framework] && !File.exist?(framework_destination_file)
+          FileUtils.mkdir('lib') unless File.directory?('lib')
+          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.file 'swfobject.js', 'public/javascripts/swfobject.js'
+        m.file 'expressInstall.swf', 'public/expressInstall.swf'
+        m.template 'index.html.erb', 'app/views/layout/application.html.erb'
+        
+        m.dependency 'ruboss_controller', @args
+      end
+      m.template 'mainapp.mxml', File.join('app/flex', "#{project_name}.mxml")
+      m.template 'mainair-app.xml', File.join('app/flex', "#{project_name}-app.xml") if @use_air
+    end
+  end
+
+  protected
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("-m", "--main-only", "Only generate the main Flex/AIR application file.", 
+        "Default: false") { |v| options[:main_only] = v }
+      opt.on("-a", "--air", "Configure AIR project instead of Flex. Flex is default.", 
+        "Default: false") { |v| options[:air_config] = v }
+      opt.on("-s", "--skip-framework", "Don't fetch the latest framework binary. You'll have to link/build the framework yourself.", 
+        "Default: false") { |v| options[:skip_framework] = v }
+    end
+
+    def banner
+      "Usage: #{$0} #{spec.name}" 
+    end
+end