dima-ruboss4ruby 1.0.5

data/lib/ruboss4ruby.rb

@@ -0,0 +1,84 @@
+module Ruboss
+  VERSION = '1.0.5'
+  RUBOSS_FRAMEWORK_VERSION = '1.0.5'
+  
+  LIB_DIR = File.join(File.dirname(__FILE__), 'ruboss4ruby/')
+end
+
+# Merb specific handling
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  Merb::Plugins.add_rakefiles 'ruboss4ruby/tasks'
+
+  Merb::BootLoader.before_app_loads do
+    require Ruboss::LIB_DIR + 'configuration'
+    
+    if defined?(ActiveRecord::Base)
+      Merb.add_mime_type(:fxml,  :to_fxml,  %w[application/xml text/xml application/x-xml], :charset => "utf-8")
+      require Ruboss::LIB_DIR + 'active_foo'
+      Merb::Plugins.add_rakefiles 'ruboss4ruby/active_record_tasks'
+    else
+      Merb.add_mime_type(:fxml,  :to_xml,  %w[application/xml text/xml application/x-xml], :charset => "utf-8")
+      if defined?(Merb::Orms::DataMapper)
+        require Ruboss::LIB_DIR + 'datamapper_foo'
+      end
+    end
+  end    
+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
+  
+  ['configuration', 'active_foo', 'rails/ruboss_helper', 
+    'rails/ruboss_test_helpers'].each { |lib| require Ruboss::LIB_DIR + lib }
+
+  ActionView::Base.send :include, RubossHelper unless ActionView::Base.included_modules.include?(RubossHelper)  
+  Test::Unit::TestCase.send :include, RubossTestHelpers unless Test::Unit::TestCase.included_modules.include?(RubossTestHelpers)
+
+  module ActionController
+    class Base
+      alias_method :old_render, :render unless method_defined?(:old_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.is_a?(Hash) && 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 RubossController
+    private
+
+    # Extract any keys named _metadata from the models in the params hash
+    # and put them in the root of the params hash.
+    def extract_metadata_from_params
+      metadata = {}
+      metadata.merge!(params.delete('_metadata')) if params.has_key?('_metadata')
+      params.each do |k, v|
+        next unless v.respond_to?(:has_key?) and v.has_key?('_metadata')
+        metadata.merge!(v.delete('_metadata'))
+      end
+      params.merge!(metadata) unless metadata.empty?
+    end  
+  end
+  
+  module ActiveRecord
+    module NamedScope
+      class Scope
+        delegate :to_fxml, :to => :proxy_found
+      end
+    end
+  end
+
+  ActionController::Base.send :include, RubossController  
+  ActionController::Base.send :prepend_before_filter, :extract_metadata_from_params  
+
+  # temporarily disable forgery protection site-wise
+  ActionController::Base.allow_forgery_protection = false
+end

data/lib/ruboss4ruby/active_foo.rb

@@ -0,0 +1,221 @@
+#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) }
+
+module ActiveSupport
+  module CoreExtensions
+    module Hash
+      module Conversions
+        def to_fxml(options = {})
+          if self.empty? && !options[:root]
+            raise "empty hash being converted to FXML must specify :root option, e.g. <class_name>.to_s.underscore.pluralize"
+          end
+          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
+    module Array
+      module Conversions
+        def to_fxml(options = {})
+          if self.empty? && !options[:root]
+            raise "empty array being converted to FXML must specify :root option, e.g. <class_name>.to_s.underscore.pluralize"
+          end
+          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
+
+module ActiveRecord
+  # Flex friendly XML serialization patches
+  class Base
+    class << self
+      # 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
+            
+      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
+          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
+
+  module Serialization
+    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
+    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/ruboss4ruby/active_record_tasks.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), '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/ruboss4ruby/configuration.rb

@@ -0,0 +1,59 @@
+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
+  
+  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 Configuration
+    APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : Merb.root
+
+    def extract_names
+      project_name = APP_ROOT.split("/").last.camelcase.gsub(/\s/, '')
+      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('.', '/').gsub(/\s/, '')
+        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
+
+    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/ruboss4ruby/datamapper_foo.rb

@@ -0,0 +1,25 @@
+require 'builder'
+require Ruboss::LIB_DIR + 'configuration'
+
+module DataMapper
+  module Validate
+    class ValidationErrors
+      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