muding 0.1.1 → 0.2.0

data/lib/model.rb

@@ -1,6 +1,5 @@
 Dir["./lib/acts/*.rb"].sort.each { |ext| load ext.to_s }
 
-ActiveRecord::Base.establish_connection(YAML.load_file("config/database.yml")["development"])
 
 ActiveRecord::Base.send :include, Acts::Expireable
 ActiveRecord::Base.send :include, Acts::Container

data/lib/muding.rb

@@ -24,7 +24,7 @@ module Muding
 			unless default_command 
 				string_array = input.split(" ")
 				command = string_array.shift
-				args = string_array.to_s 
+				args = string_array.join(" ") 
 			else
 				command = default_command.to_s
 				args = input

data/lib/muding_generator/base.rb

@@ -26,8 +26,8 @@ module Muding
         @source_root = options[:source] || File.join(spec.path, 'templates')
         if options[:destination]
           @destination_root = options[:destination]
-        elsif defined? ::RAILS_ROOT
-          @destination_root = ::RAILS_ROOT
+        elsif defined? ::MUDING_ROOT
+          @destination_root = ::MUDING_ROOT
         end
 
         # Silence the logger if requested.
@@ -101,7 +101,7 @@ module Muding
     # If no name is provided, the generator raises a usage error with content
     # optionally read from the USAGE file in the generator's base path.
     #
-    # See Rails::Generator::Base for a discussion of Manifests and Commands.
+    # See Muding::Generator::Base for a discussion of Manifests and Commands.
     class NamedBase < Base
       attr_reader   :name, :class_name, :singular_name, :plural_name, :table_name
       attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth

data/lib/muding_generator/commands.rb

@@ -2,6 +2,7 @@ require 'delegate'
 require 'optparse'
 require 'fileutils'
 require 'erb'
+require 'version'
 
 module Muding
   module Generator
@@ -23,14 +24,14 @@ module Muding
       end
 
 
-      # Generator commands delegate Rails::Generator::Base and implement
+      # Generator commands delegate Muding::Generator::Base and implement
       # a standard set of actions.  Their behavior is defined by the way
       # they respond to these actions: Create brings life; Destroy brings
       # death; List passively observes.
       #
       # Commands are invoked by replaying (or rewinding) the generator's
-      # manifest of actions.  See Rails::Generator::Manifest and
-      # Rails::Generator::Base#manifest method that generator subclasses
+      # manifest of actions.  See Muding::Generator::Manifest and
+      # Muding::Generator::Base#manifest method that generator subclasses
       # are required to override.
       #
       # Commands allows generators to "plug in" invocation behavior, which
@@ -133,7 +134,7 @@ module Muding
       class Create < Base
 
         # Check whether the given class names are already taken by
-        # Ruby or Rails.  In the future, expand to check other namespaces
+        # Ruby or Muding.  In the future, expand to check other namespaces
         # such as the rest of the user's app.
         def class_collisions(*class_names)
           class_names.flatten.each do |class_name|
@@ -252,7 +253,7 @@ module Muding
           source == destination
         end
 
-        # Generate a file for a Rails application using an ERuby template.
+        # Generate a file for a Muding application using an ERuby template.
         # Looks up and evalutes a template by name and writes the result.
         #
         # The ERB template uses explicit trim mode to best control the
@@ -321,7 +322,7 @@ module Muding
           # Thanks to Florian Gross (flgr).
           def raise_class_collision(class_name)
             message = <<end_message
-  The name '#{class_name}' is reserved by Ruby on Rails.
+  The name '#{class_name}' is reserved by Muding.
   Please choose an alternative and run this generator again.
 end_message
             if suggest = find_synonyms(class_name)

data/lib/muding_generator/generators/applications/app/app_generator.rb

@@ -43,6 +43,7 @@ class AppGenerator < Muding::Generator::Base
       #m.template "configs/routes.rb",     "config/routes.rb"
       #m.template "configs/apache.conf",   "public/.htaccess"
 			m.file "configs/boot.rb",    "config/boot.rb"
+			m.template "configs/environment.rb", "config/environment.rb", :assigns => { :freeze => options[:freeze] }
 
       # Environments
       

data/lib/muding_generator/generators/components/controller/controller_generator.rb

@@ -1,4 +1,4 @@
-class ControllerGenerator < Rails::Generator::NamedBase
+class ControllerGenerator < Muding::Generator::NamedBase
   def manifest
     record do |m|
       # Check for class naming collisions.

data/lib/muding_generator/generators/components/migration/migration_generator.rb

@@ -1,4 +1,4 @@
-class MigrationGenerator < Rails::Generator::NamedBase
+class MigrationGenerator < Muding::Generator::NamedBase
   def manifest
     record do |m|
       m.migration_template 'migration.rb', 'db/migrate'

data/lib/muding_generator/generators/components/model/model_generator.rb

@@ -1,4 +1,4 @@
-class ModelGenerator < Rails::Generator::NamedBase
+class ModelGenerator < Muding::Generator::NamedBase
   default_options :skip_migration => false
 
   def manifest

data/lib/muding_generator/lookup.rb

@@ -4,7 +4,7 @@ class Object
   class << self
     # Lookup missing generators using const_missing.  This allows any
     # generator to reference another without having to know its location:
-    # RubyGems, ~/.rails/generators, and RAILS_ROOT/generators.
+    # RubyGems, ~/.muding/generators, and MUDING_ROOT/generators.
     def lookup_missing_generator(class_id)
       if md = /(.+)Generator$/.match(class_id.to_s)
         name = md.captures.first.demodulize.underscore
@@ -90,20 +90,20 @@ module Muding
         end
 
         # Use component generators (model, controller, etc).
-        # 1.  Rails application.  If RAILS_ROOT is defined we know we're
-        #     generating in the context of a Rails application, so search
-        #     RAILS_ROOT/generators.
-        # 2.  User home directory.  Search ~/.rails/generators.
+        # 1.  muding application.  If MUDING_ROOT is defined we know we're
+        #     generating in the context of a muding application, so search
+        #     MUDING_ROOT/generators.
+        # 2.  User home directory.  Search ~/.muding/generators.
         # 3.  RubyGems.  Search for gems named *_generator.
         # 4.  Builtins.  Model, controller, mailer, scaffold.
         def use_component_sources!
           reset_sources
-          if defined? ::RAILS_ROOT
-            sources << PathSource.new(:lib, "#{::RAILS_ROOT}/lib/generators")
-            sources << PathSource.new(:vendor, "#{::RAILS_ROOT}/vendor/generators")
-            sources << PathSource.new(:plugins, "#{::RAILS_ROOT}/vendor/plugins/**/generators")
+          if defined? ::MUDING_ROOT
+            sources << PathSource.new(:lib, "#{::MUDING_ROOT}/lib/generators")
+            sources << PathSource.new(:vendor, "#{::MUDING_ROOT}/vendor/generators")
+            sources << PathSource.new(:plugins, "#{::MUDING_ROOT}/vendor/plugins/**/generators")
           end
-          sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
+          sources << PathSource.new(:user, "#{Dir.user_home}/.muding/generators")
           sources << GemSource.new if Object.const_defined?(:Gem)
           sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
         end

data/lib/muding_generator/scripts.rb

@@ -51,15 +51,15 @@ module Muding
 
             usage << <<end_blurb
 
-More are available at http://rubyonrails.org/show/Generators
+More are available at http://muding.rubyforge.org
   1. Download, for example, login_generator.zip
-  2. Unzip to directory #{Dir.user_home}/.rails/generators/login
-     to use the generator with all your Rails apps
+  2. Unzip to directory #{Dir.user_home}/.muding/generators/login
+     to use the generator with all your muding apps
 end_blurb
 
-            if Object.const_defined?(:RAILS_ROOT)
+            if Object.const_defined?(:MUDING_ROOT)
               usage << <<end_blurb
-     or to #{File.expand_path(RAILS_ROOT)}/generators/login
+     or to #{File.expand_path(MUDING_ROOT)}/generators/login
      to use with this app only.
 end_blurb
             end

data/lib/tasks/databases.rake

@@ -0,0 +1,169 @@
+namespace :db do
+  desc "Migrate the database through scripts in db/migrate. Target specific version with VERSION=x"
+  task :migrate => :environment do
+    ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+	namespace :fixtures do
+	  desc "Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+	  task :load => :environment do
+	    require 'active_record/fixtures'
+	    ActiveRecord::Base.establish_connection(MUDING_ENV.to_sym)
+	    (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+	      Fixtures.create_fixtures('test/fixtures', File.basename(fixture_file, '.*'))
+	    end
+	  end
+	end
+
+  namespace :schema do
+    desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
+    task :dump => :environment do
+      require 'active_record/schema_dumper'
+      File.open(ENV['SCHEMA'] || "db/schema.rb", "w") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+
+    desc "Load a schema.rb file into the database"
+    task :load => :environment do
+      file = ENV['SCHEMA'] || "db/schema.rb"
+      load(file)
+    end
+  end
+
+  namespace :structure do
+    desc "Dump the database structure to a SQL file"
+    task :dump => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs[MUDING_ENV]["adapter"] 
+        when "mysql", "oci"
+          ActiveRecord::Base.establish_connection(abcs[MUDING_ENV])
+          File.open("db/#{MUDING_ENV}_structure.sql", "w+") { |f| f << 
+ActiveRecord::Base.connection.structure_dump }
+        when "postgresql"
+          ENV['PGHOST']     = abcs[MUDING_ENV]["host"] if abcs[MUDING_ENV]["host"]
+          ENV['PGPORT']     = abcs[MUDING_ENV]["port"].to_s if abcs[MUDING_ENV]["port"]
+          ENV['PGPASSWORD'] = abcs[MUDING_ENV]["password"].to_s if abcs[MUDING_ENV]["password"]
+          search_path = abcs[MUDING_ENV]["schema_search_path"]
+          search_path = "--schema=#{search_path}" if search_path
+          `pg_dump -i -U "#{abcs[MUIDING_ENV]["username"]}" -s -x -O -f db/#{MUDING_ENV}_structure.sql 
+#{search_path} #{abcs[MUDING_ENV]["database"]}`
+          raise "Error dumping database" if $?.exitstatus == 1
+        when "sqlite", "sqlite3"
+          dbfile = abcs[MUDING_ENV]["database"] || abcs[MUDING_ENV]["dbfile"]
+          `#{abcs[MUDING_ENV]["adapter"]} #{dbfile} .schema > db/#{MUDING_ENV}_structure.sql`
+        when "sqlserver"
+          `scptxfr /s #{abcs[MUDING_ENV]["host"]} /d #{abcs[MUDING_ENV]["database"]} /I /f 
+db\\#{MUDING_ENV}_structure.sql /q /A /r`
+          `scptxfr /s #{abcs[MUDING_ENV]["host"]} /d #{abcs[MUDING_ENV]["database"]} /I /F db\ /q /A 
+/r`
+        else 
+          raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        File.open("db/#{MUDING_ENV}_structure.sql", "a") { |f| f << 
+ActiveRecord::Base.connection.dump_schema_information }
+      end
+    end
+  end
+
+  namespace :test do
+    desc "Recreate the test database from the current environment's database schema"
+    task :clone => "db:schema:dump" do
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecord::Schema.verbose = false
+      Rake::Task["db:schema:load"].invoke
+    end
+
+  
+    desc "Recreate the test databases from the development structure"
+    task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+      abcs = ActiveRecord::Base.configurations
+      case abcs["test"]["adapter"]
+        when "mysql"
+          ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+          IO.readlines("db/#{MUDING_ENV}_structure.sql").join.split("\n\n").each do |table|
+            ActiveRecord::Base.connection.execute(table)
+          end
+        when "postgresql"
+          ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+          ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+          ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+          `psql -U "#{abcs["test"]["username"]}" -f db/#{MUDING_ENV}_structure.sql 
+#{abcs["test"]["database"]}`
+        when "sqlite", "sqlite3"
+          dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+          `#{abcs["test"]["adapter"]} #{dbfile} < db/#{MUDING_ENV}_structure.sql`
+        when "sqlserver"
+          `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i 
+db\\#{MUDING_ENV}_structure.sql`
+        when "oci"
+          ActiveRecord::Base.establish_connection(:test)
+          IO.readlines("db/#{MUDING_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
+            ActiveRecord::Base.connection.execute(ddl)
+          end
+        else 
+          raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+    end
+
+    desc "Empty the test database"
+    task :purge => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs["test"]["adapter"]
+        when "mysql"
+          ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"])
+        when "postgresql"
+          ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+          ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+          ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+          enc_option = "-E #{abcs["test"]["encoding"]}" if abcs["test"]["encoding"]
+          `dropdb -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+          `createdb #{enc_option} -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+        when "sqlite","sqlite3"
+          dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+          File.delete(dbfile) if File.exist?(dbfile)
+        when "sqlserver"
+          dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+          `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+          `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i 
+db\\#{MUDING_ENV}_structure.sql`
+        when "oci"
+          ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+            ActiveRecord::Base.connection.execute(ddl)
+          end
+        else
+          raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+    end
+
+    desc 'Prepare the test database and load the schema'
+    task :prepare => :environment do
+      Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:clone" }[ActiveRecord::Base.schema_format]].invoke
+    end
+  end
+
+  namespace :sessions do
+    desc "Creates a sessions table for use with CGI::Session::ActiveRecordStore"
+    task :create => :environment do
+      raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+      require 'rails_generator'
+      require 'rails_generator/scripts/generate'
+      Rails::Generator::Scripts::Generate.new.run(["session_migration", ENV["MIGRATION"] || "AddSessions"])
+    end
+
+    desc "Clear the sessions table"
+    task :clear => :environment do
+      ActiveRecord::Base.connection.execute "DELETE FROM sessions"
+    end
+  end
+end
+
+def session_table_name
+  ActiveRecord::Base.pluralize_table_names ? :sessions : :session
+end

data/lib/tasks/documentation.rake

@@ -0,0 +1,55 @@
+namespace :doc do
+  desc "Generate documentation for the application"
+  Rake::RDocTask.new("app") { |rdoc|
+    rdoc.rdoc_dir = 'doc/app'
+    rdoc.title    = "Muding Application Documentation"
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('doc/README_FOR_APP')
+    rdoc.rdoc_files.include('app/**/*.rb')
+  }
+
+  desc "Generate documentation for the muding framework"
+  Rake::RDocTask.new("muding") { |rdoc|
+    rdoc.rdoc_dir = 'doc/api'
+    rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+    rdoc.title    = "muding Framework Documentation"
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('README')
+  }
+
+  plugins = FileList['vendor/plugins/**'].collect { |plugin| File.basename(plugin) }
+
+  desc "Generate documation for all installed plugins"
+  task :plugins => plugins.collect { |plugin| "doc:plugins:#{plugin}" }
+
+  desc "Remove plugin documentation"
+  task :clobber_plugins do 
+    rm_rf 'doc/plugins' rescue nil
+  end
+
+  namespace :plugins do
+    # Define doc tasks for each plugin
+    plugins.each do |plugin|
+      task(plugin => :environment) do
+        plugin_base   = "vendor/plugins/#{plugin}"
+        options       = []
+        files         = Rake::FileList.new
+        options << "-o doc/plugins/#{plugin}"
+        options << "--title '#{plugin.titlecase} Plugin Documentation'"
+        options << '--line-numbers' << '--inline-source'
+        options << '-T html'
+
+        files.include("#{plugin_base}/lib/**/*.rb")
+        if File.exists?("#{plugin_base}/README")
+          files.include("#{plugin_base}/README")    
+          options << "--main '#{plugin_base}/README'"
+        end
+        files.include("#{plugin_base}/CHANGELOG") if File.exists?("#{plugin_base}/CHANGELOG")
+
+        options << files.to_s
+
+        sh %(rdoc #{options * ' '})
+      end
+    end
+  end
+end

data/lib/tasks/muding.rb

@@ -0,0 +1,7 @@
+require "rake"
+# Load Muding-specific Rake tasks automatically.
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }
+
+# Now, get tasks from lib/tasks
+Dir["./lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+

data/lib/tasks/statistics.rake

@@ -0,0 +1,18 @@
+STATS_DIRECTORIES = [
+  %w(Helpers            mud/helpers), 
+  %w(Controllers        mud/controllers), 
+  %w(APIs               mud/apis),
+  %w(Components         components),
+  %w(Functional\ tests  test/functional),
+  %w(Models             mud/models),
+  %w(Unit\ tests        test/unit),
+  %w(Libraries          lib/),
+  %w(Integration\ tests test/integration)
+].collect { |name, dir| [ name, "#{MUDING_ROOT}/#{dir}" ] }.select { 
+|name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/lib/tasks/testing.rake

@@ -0,0 +1,102 @@
+TEST_CHANGES_SINCE = Time.now - 600
+
+# Look up tests for recently modified sources.
+def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
+  FileList[source_pattern].map do |path|
+    if File.mtime(path) > touched_since
+      test = "#{test_path}/#{File.basename(path, '.rb')}_test.rb"
+      test if File.exists?(test)
+    end
+  end.compact
+end
+
+
+# Recreated here from ActiveSupport because :uncommitted needs it before Rails is available
+module Kernel
+  def silence_stderr
+    old_stderr = STDERR.dup
+    STDERR.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    STDERR.sync = true
+    yield
+  ensure
+    STDERR.reopen(old_stderr)
+  end
+end
+
+desc 'Test all units and functionals'
+task :test do
+  Rake::Task["test:units"].invoke       rescue got_error = true
+  Rake::Task["test:functionals"].invoke rescue got_error = true
+  
+  if File.exist?("test/integration")
+    #Rake::Task["test:integration"].invoke rescue got_error = true
+  end
+
+  raise "Test failures" if got_error
+end
+
+namespace :test do
+  desc 'Test recent changes'
+  Rake::TestTask.new(:recent => "db:test:prepare") do |t|
+    since = TEST_CHANGES_SINCE
+    touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
+      recent_tests('app/models/*.rb', 'test/unit', since) +
+      recent_tests('app/controllers/*.rb', 'test/functional', since)
+
+    t.libs << 'test'
+    t.verbose = true
+    t.test_files = touched.uniq
+  end
+  
+  desc 'Test changes since last checkin (only Subversion)'
+  Rake::TestTask.new(:uncommitted => "db:test:prepare") do |t|
+    def t.file_list
+      changed_since_checkin = silence_stderr { `svn status` }.map { |path| path.chomp[7 .. -1] }
+
+      models      = changed_since_checkin.select { |path| path =~ /app\/models\/.*\.rb/ }
+      controllers = changed_since_checkin.select { |path| path =~ /app\/controllers\/.*\.rb/ }  
+
+      unit_tests       = models.map { |model| "test/unit/#{File.basename(model, '.rb')}_test.rb" }
+      functional_tests = controllers.map { |controller| "test/functional/#{File.basename(controller, '.rb')}_test.rb" }
+
+      unit_tests.uniq + functional_tests.uniq
+    end
+    
+    t.libs << 'test'
+    t.verbose = true
+  end
+
+  desc "Run the unit tests in test/unit"
+  Rake::TestTask.new(:units => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+
+  desc "Run the functional tests in test/functional"
+  Rake::TestTask.new(:functionals => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/functional/**/*_test.rb'
+    t.verbose = true
+  end
+
+  desc "Run the integration tests in test/integration"
+  Rake::TestTask.new(:integration => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/integration/**/*_test.rb'
+    t.verbose = true
+  end
+
+  desc "Run the plugin tests in vendor/plugins/**/test (or specify with PLUGIN=name)"
+  Rake::TestTask.new(:plugins => :environment) do |t|
+    t.libs << "test"
+
+    if ENV['PLUGIN']
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN']}/test/**/*_test.rb"
+    else
+      t.pattern = 'vendor/plugins/**/test/**/*_test.rb'
+    end
+
+    t.verbose = true
+  end
+end