ruboss4ruby 1.0.5 → 1.1.0

data/lib/ruboss4ruby/active_foo.rb

@@ -1,4 +1,15 @@
-#ActiveRecord+ActiveSupport specific patches
+# 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")
@@ -7,129 +18,140 @@ ActiveSupport::CoreExtensions::Time::Conversions::DATE_FORMATS.merge!(:flex_date
 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
-
+# 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)
-          to_xml(options)
+          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 = {})
-          options.merge!(:dasherize => false)
-          to_xml(options)
-        end
-      end
-    end
-  end
-end
+          raise "Not all elements respond to to_fxml" unless all? { |e| e.respond_to? :to_fxml }
 
-module ActiveRecord
-  # Flex friendly XML serialization patches
-  class Base
-    class << self
-      alias_method :old_find, :find unless method_defined?(:old_find)
+          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)
 
-      def find(*args)
-        result = old_find(*args)
-        if result.class == Array and result.empty?
-          result = ClassyEmptyArray.new(self.class_name.tableize)
-        end
-        result
-      end
+          root     = options.delete(:root).to_s
+          children = options.delete(:children)
 
-      # 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
+          if !options.has_key?(:dasherize) || options[:dasherize]
+            root = root.dasherize
           end
-        END
-      end
-            
-      def default_fxml_hash(already_included = [])
-        # return {} unless self.class.respond_to?(:default_fxml_include_params) || self.class.respond_to?(:default_fxml_methods_array)
-        default_hash = {:include => {}}
-        default_hash[:methods] = self.default_fxml_methods_array if self.respond_to?(:default_fxml_methods_array)
-        if self.respond_to?(:default_fxml_include_params)
-          default_includes = self.default_fxml_include_params
-          default_hash[:include] = default_includes.inject({}) do |include_hash, included|
-            next if already_included.include?(included) # We only want to include things once, to avoid infinite loops
-            included_class = included.to_s.singularize.camelize.constantize
-            include_hash[included] = included_class.default_fxml_hash(already_included + default_includes) 
-            include_hash
+
+          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
-        default_hash
-      end 
-      
-    # options[:include] can be a Hash, Array, Symbol or nil.
-    # We always want it as a Hash.  This translates includes to a Hash like this:
-    # If it's a nil, return an empty Hash ({})
-    # If it's a Hash, then it is just returned
-    # If it's an array, then it returns a Hash with each array element as a key, and values of empty Hashes.
-    # If it's a symbol, then it returns a Hash with a single key/value pair, with the symbol as the key and an empty Hash as the value.
-    def includes_as_hash(includes = nil)      
-      res = case
-        when includes.is_a?(Hash)
-          includes      
-        when includes.nil?
-         {}  
-        else #Deal with arrays and symbols
-          res = [includes].flatten.inject({}) {|include_hash, included| include_hash[included] = {} ; include_hash}
       end
-      res
-    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
-    def to_fxml(options = {})
+    # 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)
-      options[:methods] = [options[:methods] || []].flatten + (self.class.default_fxml_hash[:methods] || [])
-      options[:include] = self.class.default_fxml_hash[:include].merge(self.class.includes_as_hash(options[:include]))
-      to_xml(options)
+      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    
+    end
+    # Strips '?' from serialized method names
     class Attribute
+      # Strips '?' from serialized method names
       def display_name
         @name.gsub('?','')
       end
@@ -139,6 +161,7 @@ module ActiveRecord
   # 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

data/lib/ruboss4ruby/active_record_default_methods.rb

@@ -0,0 +1,66 @@
+module ActiveRecord
+  #
+  # We also add support for serializing model methods along the lines of:
+  #
+  #   class Project < ActiveRecord::Base
+  #     default_methods :foobar
+  #
+  #     def foobar
+  #       'foobar'
+  #     end
+  #   end
+  #
+  # When you do +to_fxml+ on this model method foobar will be automatically
+  # serialized as a simple attribute
+  class Base
+    class << self
+            
+      # default methods hook
+      def default_methods(*args)
+        methods = *args.dup
+        module_eval <<-END 
+            def self.default_methods_array
+              return [#{methods.inspect}].flatten
+            end
+          END
+      end
+      
+      # default methods hook
+      def defaults_hash(already_included = [], ignore_default_methods = nil)
+        defaults_hash = {:include => {}}
+        unless ignore_default_methods
+          defaults_hash[:methods] = self.default_methods_array if self.respond_to?(:default_methods_array)
+        end
+        defaults_hash
+      end 
+    end
+  end    
+  
+  # Flex-friendly serialization patches
+  module Serialization
+    
+    alias_method :xml_defaults_old_to_xml, :to_xml unless method_defined?(:xml_defaults_old_to_xml)
+    
+    alias_method :json_defaults_old_to_json, :to_json unless method_defined?(:json_defaults_old_to_json)
+    
+    # adds support for default_methods to standard +to_xml+
+    def to_xml(options = {}, &block)
+      unless options[:ignore_defaults]
+        unless options[:ignore_default_methods]
+          options[:methods] = [options[:methods] || []].flatten + (self.class.defaults_hash[:methods] || [])
+        end
+      end
+      xml_defaults_old_to_xml(options, &block)
+    end
+    
+    # adds support for default_methods to standard +to_json+
+    def to_json(options = {}, &block)
+      unless options[:ignore_defaults]
+        unless options[:ignore_default_methods]
+          options[:methods] = [options[:methods] || []].flatten + (self.class.defaults_hash[:methods] || [])
+        end
+      end
+      json_defaults_old_to_json(options, &block)      
+    end
+  end
+end

data/lib/ruboss4ruby/active_record_tasks.rb

@@ -1,7 +1,10 @@
-require 'ruboss4ruby/tasks'
-
-# these tasks are active record specific
+# 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
@@ -26,7 +29,10 @@ namespace :db do
       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 = ""
     

data/lib/ruboss4ruby/configuration.rb

@@ -1,60 +1,74 @@
+# 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
-  def capitalize_without_downcasing
+  # Upper-case first character of a string leave the rest of the string intact
+  def ucfirst
     self[0,1].capitalize + self[1..-1]
   end
   
-  def downcase_first_letter
+  # Down-case first character of a string leaving the rest of it intact
+  def dcfirst
     self[0,1].downcase + self[1..-1]
   end
-  
-  def camelcase(first_letter = :upper)
-    case first_letter
-      when :upper then self.camelize(true)
-      when :lower then self.camelize(false)
-    end
-  end
-
-  def camelize(first_letter_in_uppercase = true)
-    if first_letter_in_uppercase
-      self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-    else
-      self[0,1].downcase + self.camelize[1..-1]
-    end
-  end
-
-  def underscore
-    self.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
 end
 
-module Ruboss
+module Ruboss4Ruby
+  # 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 : Merb.root
-
-    def extract_names
-      project_name = APP_ROOT.split("/").last.camelcase
-      project_name_downcase = project_name.downcase
+    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/ruboss.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 ruboss.yml file:
+    #
+    # Ruboss 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 ruboss 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 ruboss.yml
       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"
+        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 = "#{project_name}Controller"
+        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

data/lib/ruboss4ruby/datamapper_foo.rb

@@ -0,0 +1,31 @@
+require 'builder'
+require Ruboss4Ruby::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/ruboss4ruby/{recipes.rb → rails/recipes.rb}

@@ -1,10 +1,11 @@
-require 'find'
-
+# Adds Capistrano recipes for deploying Flex applications
+#
 # To use these recipes, add the following to your Capfile:
-# require 'ruboss4ruby/recipes'
+#
+#   require 'ruboss4ruby/rails/recipes'
+require 'find'
 
 Capistrano::Configuration.instance(:must_exist).load do
-
   after "deploy:setup", "deploy:flex:setup"
 
   namespace :db do
@@ -15,7 +16,6 @@ Capistrano::Configuration.instance(:must_exist).load do
   end
 
   namespace :deploy do
-  
     namespace :flex do
     
       desc "Creates the flex_files directory in the shared directory"
@@ -28,7 +28,7 @@ Capistrano::Configuration.instance(:must_exist).load do
       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 = File.join(File.dirname(__FILE__), '..', '..', '..', '..')
+        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')
     
@@ -46,7 +46,7 @@ Capistrano::Configuration.instance(:must_exist).load do
       desc "synchronizes the local and remote public/bin directories using rsync"
       task :via_rsync, :roles => :app do      
         username = user || ENV['USER']
-        rails_root = File.join(File.dirname(__FILE__), '..', '..', '..', '..')
+        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
@@ -55,8 +55,6 @@ Capistrano::Configuration.instance(:must_exist).load do
       task :make_symlink, :roles => :app do
         run "ln -s #{shared_path}/flex_files #{release_path}/public/bin"
       end
-  
     end
   end
-  
 end

data/lib/ruboss4ruby/{ruboss_helper.rb → rails/swf_helper.rb}

@@ -1,4 +1,5 @@
-module RubossHelper
+# 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
@@ -13,28 +14,33 @@ module RubossHelper
                            :params => nil,
                            :attributes => nil,
                            :create_div => false, 
-                           :include_authenticity_token => true
+                           :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 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 it yourself 
+    # 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 Ruboss.defaultMetadata, so that it will be sent
     # back up to your Rails app with every request.
-    if params[:include_authenticity_token] && ActionController::Base.allow_forgery_protection
-      params[:flash_vars] = {} if params[:flash_vars].nil?
-      if params[:flash_vars].is_a?(Hash)
+    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
-    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)

data/lib/ruboss4ruby/tasks.rb

@@ -1,11 +1,14 @@
+# Rake tasks for building Ruboss-based Flex and AIR applications
 require 'rake'
 require 'ftools'
 require 'rexml/document'
-require 'ruboss4ruby/configuration'
+require File.join(File.dirname(__FILE__), 'configuration')
 
-APP_ROOT = Ruboss::Configuration::APP_ROOT
+APP_ROOT = Ruboss4Ruby::Configuration::APP_ROOT
 
 namespace :ruboss 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|
@@ -14,10 +17,10 @@ namespace :ruboss do
       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'))
+      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}"
+        "-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)
@@ -43,11 +46,13 @@ namespace :ruboss do
     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
   end
   
+  # Get appropriate executable based on platform
   def get_executable(executable)
     if RUBY_PLATFORM =~ /mswin32/
       executable << '.exe'