captproton-restfulx 1.2.3

data/lib/restfulx/active_record_tasks.rb

@@ -0,0 +1,90 @@
+# ActiveRecord specific Rake tasks. Namely, nice little extras such as:
+# - db:mysql:stage
+# - db:refresh
+require File.join(File.dirname(__FILE__), 'tasks')
+require File.join(File.dirname(__FILE__), 'rails', 'schema_to_yaml')
+
+# 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']
+  
+  # used to analyze your schema and dump out a model.yml file for converting old rails projects
+  namespace :schema do
+    desc "Create model.yml from schema.rb"
+    task :to_yaml => :environment do
+      SchemaToYaml.schema_to_yaml
+    end
+  end
+end

data/lib/restfulx/active_record_uuid_helper.rb

@@ -0,0 +1,17 @@
+# Patches ActiveRecord models to use UUID based IDs instead of the default numeric ones
+require 'uuidtools'
+
+# Extends ActiveRecord models with UUID based IDs
+module RestfulX
+  module UUIDHelper
+    def self.included(base)
+      base.class_eval do 
+        before_create :generate_uuid
+      end
+    end
+  
+    def generate_uuid
+      self.id = UUIDTools::UUID.random_create.to_s.gsub("-", "") unless self.id
+    end
+  end
+end

data/lib/restfulx/configuration.rb

@@ -0,0 +1,75 @@
+# 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.
+require "yaml" 
+require "erb" 
+require File.dirname(__FILE__) + "/rails/schema_to_yaml/settings/config" 
+require File.dirname(__FILE__) + "/rails/schema_to_yaml/settings/core" 
+
+Dir[File.dirname(__FILE__) + "/rails/schema_to_yaml/extensions/*.rb"].each do |f|
+  require f
+end
+
+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
+
+# Primary RestfulX configuration options
+module RestfulX
+  # Computes necessary configuration options from the environment. This can be used in Rails, Merb
+  # or standalone from the command line.
+  module Configuration
+    # We try to figure out the application root using a number of possible options
+    APP_ROOT = defined?(RAILS_ROOT) ? RAILS_ROOT : defined?(Merb) ? Merb.root : File.expand_path(".")
+    
+    RxSettings = SchemaToYaml::Settings::Core
+
+    # Extract project, package, controller name, etc from the environment. This will respect
+    # config/restfulx.yml if it exists, you can override all of the defaults there.
+    def extract_names(project = nil)
+      if project
+        project_name = project.downcase.gsub(/\W/, '')
+        flex_project_name = project_name.camelize
+      else
+        project_name = APP_ROOT.split("/").last.gsub(/\W/, '')
+        flex_project_name = project_name.camelize
+      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'] || flex_project_name.downcase
+        base_folder = base_package.gsub('.', '/')
+        project_name = config['project_name'].downcase.gsub(/\W/, '') || project_name
+        flex_project_name = project_name.camelize
+        controller_name = config['controller_name'] || "ApplicationController"
+        flex_root = config['flex_root'] || "app/flex"
+        distributed = config['distributed'] || false
+      rescue
+        base_folder = base_package = flex_project_name.downcase
+        controller_name = "ApplicationController"
+        flex_root = "app/flex"
+        distributed = false
+      end
+      [project_name, flex_project_name, controller_name, base_package, base_folder, flex_root, distributed]
+    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,81 @@
+# Flex friendly DataMapper patches, more specifically we just add +to_xml+ on 
+# 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
+    # Serialize a Resource to JavaScript Object Notation (JSON; RFC 4627)
+    #
+    # @return <String> a JSON representation of the Resource
+    def to_json(*args)
+      options = args.first || {}
+      result = '{ '
+      fields = []
+
+      propset = properties_to_serialize(options)
+
+      fields += propset.map do |property|
+        "#{property.name.to_json}: #{send(property.getter).to_json}"
+      end
+      
+      fields << "\"ruby_class\": #{self.class.to_json}"
+
+      # add methods
+      (options[:methods] || []).each do |meth|
+        if self.respond_to?(meth)
+          fields << "#{meth.to_json}: #{send(meth).to_json}"
+        end
+      end
+
+      # Note: if you want to include a whole other model via relation, use :methods
+      # comments.to_json(:relationships=>{:user=>{:include=>[:first_name],:methods=>[:age]}})
+      # add relationships
+      # TODO: This needs tests and also needs to be ported to #to_xml and #to_yaml
+      (options[:relationships] || {}).each do |rel,opts|
+        if self.respond_to?(rel)
+          fields << "#{rel.to_json}: #{send(rel).to_json(opts)}"
+        end
+      end
+
+      result << fields.join(', ')
+      result << ' }'
+      result
+    end
+  end
+    
+  # 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 = DataMapper::Serialize::XMLSerializers::SERIALIZER
+        doc ||= xml.new_document
+        root = xml.root_node(doc, "errors")
+        @errors.each_key do |attribute|
+          @errors[attribute].each do |msg|
+            next if msg.nil?
+            if attribute == "base"
+              xml.add_node(root, "error", nil, {"message" => msg})
+            else
+              xml.add_node(root, "error", nil, {"field" => attribute.to_s.camel_case.dcfirst, "message" => msg})
+            end
+          end
+        end
+        xml.output(doc)
+      end
+      
+      # Add to_json support for datamapper errors too
+      def to_json
+        @errors.to_json
+      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/schema_to_yaml.rb

@@ -0,0 +1,112 @@
+# 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
+  #  - set of commands that introspects your database and formats your model.yml for export
+  def self.schema_to_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 - 
+      %w(schema_info schema_migrations).map - 
+      RxSettings.ignored.tables[0].split
+      
+    # Excludes columns from each table
+    disregarded_columns = %w(id created_at updated_at) + RxSettings.ignored.fields[0].split
+    
+    # Schema variable is appended to throughout, and is the variable exported to model.yml
+    schema = []
+    
+    # Set up empty array for has_many relationships
+    @array_of_has_manies = []
+
+    # Iterates through each table, and checks for any database field ending in _id
+    table_arr.each do |table|
+      column_arr = ActiveRecord::Base.connection.columns(table)
+      column_arr.each do |col|
+        col_name = col.name.to_s
+        @array_of_has_manies << "#{col_name.gsub(/_id\b/,'')}_#{table}" if col_name[-3,3]=='_id'
+      end
+    end
+
+    table_arr.each do |table|
+      # Set up empty arrays for other associations
+      belong_tos = []
+      has_manies = []
+      polymorphics = []
+
+      # Append table name to schema
+      #  - project:
+      schema << "#{table.singularize}:\n" 
+      column_arr = ActiveRecord::Base.connection.columns(table)
+
+      column_arr.each do |col|
+        col_name = col.name.to_s
+        
+        # Ignore certain columns
+        columns_check = []
+        disregarded_columns.each {|dc| columns_check << col_name.include?(dc) }
+        
+        # Sets up polymorphics array, we'll need to check for duplicates below
+        polymorphics << col_name.gsub('_id','PMCHECK').gsub('_type','PMCHECK')
+
+        # Appends each column under respective table
+        schema << " - #{col_name}: #{col.type}\n" unless columns_check.include?(true)
+
+        # Checks for certain column names
+        #  - If it finds parent_id it sets up a tree_model for generation
+        #  - If it finds _file_size it sets up attachment for generation
+        #  - Sets up belong_tos
+        if col_name == 'parent_id'
+          schema << " - tree_model: [#{col_name.gsub(/_id\b/,'')}]\n" 
+        elsif col_name =~ /_file_size$/
+          schema << " - attachment_field: [#{col_name.gsub(/_file_size$/,'')}]\n" 
+        else
+          belong_tos << col_name.gsub(/_id\b/,', ') if col_name[-3,3]=='_id' && !disregarded_columns.include?(col_name)
+        end
+      end
+
+      # Checks for duplicates in the polymorphics array (used for error checking)
+      if polymorphics.dups.size > 0
+        schema << " - polymorphic: [#{polymorphics.dups.first.gsub('PMCHECK','')}]\n" 
+        @polymorphic = polymorphics.dups.first.gsub('PMCHECK','')
+      end
+
+      # Cleans up has many
+      @array_of_has_manies.each do |hm|
+        sanity_check = hm.gsub(/^#{table.singularize}_/,'')
+        if hm =~ /^#{table.singularize}_/ && table_arr.include?(sanity_check)
+          has_manies << hm.gsub(/^#{table.singularize}_/,'') + ', '
+        end
+      end
+
+      # Appends belong_to's to schema ##Patch here ## http://gist.github.com/151713 if all of the belongs_to on a particular table are polymorphic, then belong_tos is empty, so belong_tos.last is nil, so 87 (before patch) blows up
+      if belong_tos.size > 0
+        belong_tos = belong_tos.delete_if {|x| x == "#{@polymorphic}, " }
+        if belong_tos.size > 0
+          last_in_array_fix = belong_tos.last
+          last_in_array_fix = last_in_array_fix.gsub(', ','')
+          belong_tos.pop
+          belong_tos << last_in_array_fix
+          schema << " - belongs_to: [#{belong_tos}]\n"
+        end
+      end
+
+      # 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(', ','')
+        has_manies.pop
+        has_manies << last_in_array_fix
+        schema << " - has_many: [#{has_manies}]\n" 
+      end
+
+      schema << "\n" 
+    end
+
+    # 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" 
+  end
+end

data/lib/restfulx/rails/schema_to_yaml/extensions/enumerable.rb

@@ -0,0 +1,8 @@
+# Enumerable extensions
+module Enumerable
+  # Helps you find duplicates
+  # used in schema_to_yaml.rb for cleanup
+  def dups
+    inject({}) {|h,v| h[v]=h[v].to_i+1; h}.reject{|k,v| v==1}.keys
+  end
+end