muding 0.1.0

data/lib/muding_generator/generators/applications/app/USAGE

@@ -0,0 +1,14 @@
+Description:
+    The 'muding' command creates a new MUD with a default
+    directory structure and configuration at the path you specify.
+
+Example:
+    muding ~/Code/Ruby/mymud
+
+    This generates a skeletal muding installation in ~/Code/Ruby/mymud.
+    See the README in the newly created application to get going.
+
+WARNING:
+    Only specify --without-gems if you did not use gems to install muding.
+    Your application will expect to find it's dependencies in the vendor
+		directory.

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

@@ -0,0 +1,132 @@
+require 'rbconfig'
+
+class AppGenerator < Muding::Generator::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+  
+  DATABASES = %w( mysql oracle postgresql sqlite2 sqlite3 )
+  
+  default_options   :db => "mysql", :shebang => DEFAULT_SHEBANG, :freeze => false
+  mandatory_options :source => "#{File.dirname(__FILE__)}/../../../../.."
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    usage("Databases supported for preconfiguration are: #{DATABASES.join(", ")}") if (options[:db] && !DATABASES.include?(options[:db]))
+    @destination_root = args.shift
+  end
+
+  def manifest
+    # Use /usr/bin/env if no special shebang was specified
+    script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
+    dispatcher_options = { :chmod => 0755, :shebang => options[:shebang] }
+
+    record do |m|
+      # Root directory and all subdirectories.
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      # Root
+      m.file "fresh_rakefile", "Rakefile"
+      m.file "README",         "README"
+
+      # Application
+      m.template "helpers/mud.rb",        "mud/controllers/mud.rb"
+      m.template "helpers/mud_helper.rb", "mud/helpers/mud_helper.rb"
+      m.template "helpers/test_helper.rb",        "test/test_helper.rb"
+
+      # database.yml and .htaccess
+      m.template "configs/databases/#{options[:db]}.yml", "config/database.yml", :assigns => {
+        :app_name => File.basename(File.expand_path(@destination_root)),
+        :socket   => options[:db] == "mysql" ? mysql_socket_location : nil
+      }
+      #m.template "configs/routes.rb",     "config/routes.rb"
+      #m.template "configs/apache.conf",   "public/.htaccess"
+			m.file "configs/boot.rb",    "config/boot.rb"
+
+      # Environments
+      
+      #m.template "environments/environment.rb", "config/environment.rb", :assigns => { :freeze => options[:freeze] }
+      #m.file "environments/production.rb",  "config/environments/production.rb"
+      #m.file "environments/development.rb", "config/environments/development.rb"
+      #m.file "environments/test.rb",        "config/environments/test.rb"
+
+      # Scripts
+      %w( server generate console destroy ).each do |file|
+        m.file "bin/#{file}", "script/#{file}", script_options
+      end
+
+
+
+      # Docs
+      m.file "doc/README_FOR_MUD", "doc/README_FOR_MUD"
+
+      # Logs
+      #%w(server production development test).each { |file|
+      #  m.file "configs/empty.log", "log/#{file}.log", :chmod => 0666
+      #}
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} /path/to/your/mud [options]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("-r", "--ruby=path", String,
+             "Path to the Ruby binary of your choice (otherwise scripts use env, dispatchers current path).",
+             "Default: #{DEFAULT_SHEBANG}") { |v| options[:shebang] = v }
+
+      opt.on("-d", "--database=name", String,
+            "Preconfigure for selected database (options: mysql/oracle/postgresql/sqlite2/sqlite3).",
+            "Default: mysql") { |v| options[:db] = v }
+
+      opt.on("-f", "--freeze", 
+            "Freeze Muding in vendor/muding from the gems generating the skeleton",
+            "Default: false") { |v| options[:freeze] = v }
+    end
+    
+    def mysql_socket_location
+      RUBY_PLATFORM =~ /mswin32/ ? MYSQL_SOCKET_LOCATIONS.find { |f| File.exists?(f) } : nil
+    end
+
+
+  # Installation skeleton.  Intermediate directories are automatically
+  # created so don't sweat their absence here.
+  BASEDIRS = %w(
+    mud/controllers
+    mud/helpers
+    mud/models
+    mud/views/layouts
+    config
+    db
+    doc
+    lib
+    lib/tasks
+    log
+    script/performance
+    script/process
+    test/fixtures
+    test/functional
+    test/integration
+    test/mocks/development
+    test/mocks/test
+    test/unit
+    vendor
+    vendor/plugins
+  )
+
+  MYSQL_SOCKET_LOCATIONS = [
+    "/tmp/mysql.sock",                        # default
+    "/var/run/mysqld/mysqld.sock",            # debian/gentoo
+    "/var/tmp/mysql.sock",                    # freebsd
+    "/var/lib/mysql/mysql.sock",              # fedora
+    "/opt/local/lib/mysql/mysql.sock",        # fedora
+    "/opt/local/var/run/mysqld/mysqld.sock",  # mac + darwinports + mysql
+    "/opt/local/var/run/mysql4/mysqld.sock",  # mac + darwinports + mysql4
+    "/opt/local/var/run/mysql5/mysqld.sock"   # mac + darwinports + mysql5
+  ]
+end

data/lib/muding_generator/generators/components/controller/USAGE

@@ -0,0 +1,30 @@
+Description:
+    The controller generator creates stubs for a new controller and its views.
+
+    The generator takes a controller name and a list of views as arguments.
+    The controller name may be given in CamelCase or under_score and should
+    not be suffixed with 'Controller'.  To create a controller within a
+    module, specify the controller name as 'module/controller'.
+
+    The generator creates a controller class in mud/controllers with view
+    templates in mud/views/controller_name, a helper class in mud/helpers,
+    and a functional test suite in test/functional.
+
+Example:
+    ./script/generate controller CreditCard open debit credit close
+
+    Credit card controller with URLs like /credit_card/debit.
+        Controller: mud/controllers/credit_card_controller.rb
+        Views:      mud/views/credit_card/debit.rhtml [...]
+        Helper:     mud/helpers/credit_card_helper.rb
+        Test:       test/functional/credit_card_controller_test.rb
+
+Modules Example:
+    ./script/generate controller 'admin/credit_card' suspend late_fee
+
+    Credit card admin controller with URLs /admin/credit_card/suspend.
+        Controller: mud/controllers/admin/credit_card_controller.rb
+        Views:      mud/views/admin/credit_card/debit.rhtml [...]
+        Helper:     mud/helpers/admin/credit_card_helper.rb
+        Test:       test/functional/admin/credit_card_controller_test.rb
+

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

@@ -0,0 +1,38 @@
+class ControllerGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, "#{class_name}Controller", "#{class_name}ControllerTest", "#{class_name}Helper"
+
+      # Controller, helper, views, and test directories.
+      m.directory File.join('mud/controllers', class_path)
+      m.directory File.join('mud/helpers', class_path)
+      m.directory File.join('mud/views', class_path, file_name)
+      m.directory File.join('test/functional', class_path)
+
+      # Controller class, functional test, and helper class.
+      m.template 'controller.rb',
+                  File.join('mud/controllers',
+                            class_path,
+                            "#{file_name}_controller.rb")
+
+      m.template 'functional_test.rb',
+                  File.join('test/functional',
+                            class_path,
+                            "#{file_name}_controller_test.rb")
+
+      m.template 'helper.rb',
+                  File.join('mud/helpers',
+                            class_path,
+                            "#{file_name}_helper.rb")
+
+      # View template for each action.
+      actions.each do |action|
+        path = File.join('mud/views', class_path, file_name, "#{action}.rhtml")
+        m.template 'view.rhtml',
+          path,
+          :assigns => { :action => action, :path => path }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+class <%= class_name %>Controller < MudController
+<% for action in actions -%>
+
+  def <%= action %>
+  end
+<% end -%>
+end

data/lib/muding_generator/generators/components/controller/templates/functional_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+require '<%= file_path %>_controller'
+
+# Re-raise errors caught by the controller.
+class <%= class_name %>Controller; def rescue_action(e) raise e end; end
+
+class <%= class_name %>ControllerTest < Test::Unit::TestCase
+  def setup
+    @controller = <%= class_name %>Controller.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/lib/muding_generator/generators/components/controller/templates/helper.rb

@@ -0,0 +1,2 @@
+module <%= class_name %>Helper
+end

data/lib/muding_generator/generators/components/controller/templates/view.rhtml

@@ -0,0 +1,2 @@
+<h1><%= class_name %>#<%= action %></h1>
+<p>Find me in <%= path %></p>

data/lib/muding_generator/generators/components/migration/USAGE

@@ -0,0 +1,14 @@
+Description:
+    The migration generator creates a stub for a new database migration.
+
+    The generator takes a migration name as its argument.  The migration name may be
+    given in CamelCase or under_score.
+
+    The generator creates a migration class in db/migrate prefixed by its number
+    in the queue.
+
+Example:
+    ./script/generate migration AddSslFlag
+
+    With 4 existing migrations, this will create an AddSslFlag migration in the
+    file db/migrate/005_add_ssl_flag.rb

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

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

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

@@ -0,0 +1,7 @@
+class <%= class_name %> < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end

data/lib/muding_generator/generators/components/model/USAGE

@@ -0,0 +1,19 @@
+Description:
+    The model generator creates stubs for a new model.
+
+    The generator takes a model name as its argument.  The model name may be
+    given in CamelCase or under_score and should not be suffixed with 'Model'.
+
+    The generator creates a model class in mud/models, a test suite in
+    test/unit, test fixtures in test/fixtures/singular_name.yml, and a migration
+    in db/migrate.
+
+Example:
+    ./script/generate model Account
+
+    This will create an Account model:
+        Model:      mud/models/account.rb
+        Test:       test/unit/account_test.rb
+        Fixtures:   test/fixtures/accounts.yml
+        Migration:  db/migrate/XXX_add_accounts.rb
+

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

@@ -0,0 +1,34 @@
+class ModelGenerator < Rails::Generator::NamedBase
+  default_options :skip_migration => false
+
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name, "#{class_name}Test"
+
+      # Model, test, and fixture directories.
+      m.directory File.join('mud/models', class_path)
+      m.directory File.join('test/unit', class_path)
+      m.directory File.join('test/fixtures', class_path)
+
+      # Model class, unit test, and fixtures.
+      m.template 'model.rb',      File.join('mud/models', class_path, "#{file_name}.rb")
+      m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
+      m.template 'fixtures.yml',  File.join('test/fixtures', class_path, "#{table_name}.yml")
+
+      unless options[:skip_migration]
+        m.migration_template 'migration.rb', 'db/migrate', :assigns => {
+          :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+        }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+      end
+    end
+  end
+
+  protected
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("--skip-migration", 
+             "Don't generate a migration file for this model") { |v| options[:skip_migration] = v }
+    end
+end

data/lib/muding_generator/generators/components/model/templates/fixtures.yml

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first:
+  id: 1
+another:
+  id: 2

data/lib/muding_generator/generators/components/model/templates/migration.rb

@@ -0,0 +1,11 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+      # t.column :name, :string
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

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

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/lib/muding_generator/generators/components/model/templates/unit_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  fixtures :<%= table_name %>
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/lib/muding_generator/lookup.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/spec'
+
+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.
+    def lookup_missing_generator(class_id)
+      if md = /(.+)Generator$/.match(class_id.to_s)
+        name = md.captures.first.demodulize.underscore
+        Muding::Generator::Base.lookup(name).klass
+      else
+        const_missing_before_generators(class_id)
+      end
+    end
+
+    unless respond_to?(:const_missing_before_generators)
+      alias_method :const_missing_before_generators, :const_missing
+      alias_method :const_missing, :lookup_missing_generator
+    end
+  end
+end
+
+# User home directory lookup adapted from RubyGems.
+def Dir.user_home
+  if ENV['HOME']
+    ENV['HOME']
+  elsif ENV['USERPROFILE']
+    ENV['USERPROFILE']
+  elsif ENV['HOMEDRIVE'] and ENV['HOMEPATH']
+    "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+  else
+    File.expand_path '~'
+  end
+end
+
+
+module Muding
+  module Generator
+
+    # Generator lookup is managed by a list of sources which return specs
+    # describing where to find and how to create generators.  This module
+    # provides class methods for manipulating the source list and looking up
+    # generator specs, and an #instance wrapper for quickly instantiating
+    # generators by name.
+    #
+    # A spec is not a generator:  it's a description of where to find
+    # the generator and how to create it.  A source is anything that
+    # yields generators from #each.  PathSource and GemSource are provided.
+    module Lookup
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        base.use_component_sources!
+      end
+
+      # Convenience method to instantiate another generator.
+      def instance(generator_name, args, runtime_options = {})
+        self.class.instance(generator_name, args, runtime_options)
+      end
+
+      module ClassMethods
+        # The list of sources where we look, in order, for generators.
+        def sources
+          read_inheritable_attribute(:sources) or use_component_sources!
+        end
+
+        # Add a source to the end of the list.
+        def append_sources(*args)
+          sources.concat(args.flatten)
+          invalidate_cache!
+        end
+
+        # Add a source to the beginning of the list.
+        def prepend_sources(*args)
+          write_inheritable_array(:sources, args.flatten + sources)
+          invalidate_cache!
+        end
+
+        # Reset the source list.
+        def reset_sources
+          write_inheritable_attribute(:sources, [])
+          invalidate_cache!
+        end
+
+        # Use application generators (app, ?).
+        def use_application_sources!
+          reset_sources
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/applications")
+        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.
+        # 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")
+          end
+          sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
+          sources << GemSource.new if Object.const_defined?(:Gem)
+          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
+        end
+
+        # Lookup knows how to find generators' Specs from a list of Sources.
+        # Searches the sources, in order, for the first matching name.
+        def lookup(generator_name)
+          @found ||= {}
+          generator_name = generator_name.to_s.downcase
+          @found[generator_name] ||= cache.find { |spec| spec.name == generator_name }
+          unless @found[generator_name] 
+            chars = generator_name.scan(/./).map{|c|"#{c}.*?"}
+            rx = /^#{chars}$/
+            gns = cache.select{|spec| spec.name =~ rx }
+            @found[generator_name] ||= gns.first if gns.length == 1
+            raise GeneratorError, "Pattern '#{generator_name}' matches more than one generator: #{gns.map{|sp|sp.name}.join(', ')}" if gns.length > 1
+          end
+          @found[generator_name] or raise GeneratorError, "Couldn't find '#{generator_name}' generator"
+        end
+
+        # Convenience method to lookup and instantiate a generator.
+        def instance(generator_name, args = [], runtime_options = {})
+          lookup(generator_name).klass.new(args, full_options(runtime_options))
+        end
+
+        private
+          # Lookup and cache every generator from the source list.
+          def cache
+            @cache ||= sources.inject([]) { |cache, source| cache + source.map }
+          end
+
+          # Clear the cache whenever the source list changes.
+          def invalidate_cache!
+            @cache = nil
+          end
+      end
+    end
+
+    # Sources enumerate (yield from #each) generator specs which describe
+    # where to find and how to create generators.  Enumerable is mixed in so,
+    # for example, source.collect will retrieve every generator.
+    # Sources may be assigned a label to distinguish them.
+    class Source
+      include Enumerable
+
+      attr_reader :label
+      def initialize(label)
+        @label = label
+      end
+
+      # The each method must be implemented in subclasses.
+      # The base implementation raises an error.
+      def each
+        raise NotImplementedError
+      end
+
+      # Return a convenient sorted list of all generator names.
+      def names
+        map { |spec| spec.name }.sort
+      end
+    end
+
+
+    # PathSource looks for generators in a filesystem directory.
+    class PathSource < Source
+      attr_reader :path
+
+      def initialize(label, path)
+        super label
+        @path = path
+      end
+
+      # Yield each eligible subdirectory.
+      def each
+        Dir["#{path}/[a-z]*"].each do |dir|
+          if File.directory?(dir)
+            yield Spec.new(File.basename(dir), dir, label)
+          end
+        end
+      end
+    end
+
+
+    # GemSource hits the mines to quarry for generators.  The latest versions
+    # of gems named *_generator are selected.
+    class GemSource < Source
+      def initialize
+        super :RubyGems
+      end
+
+      # Yield latest versions of generator gems.
+      def each
+        Gem::cache.search(/_generator$/).inject({}) { |latest, gem|
+          hem = latest[gem.name]
+          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
+          latest
+        }.values.each { |gem|
+          yield Spec.new(gem.name.sub(/_generator$/, ''), gem.full_gem_path, label)
+        }
+      end
+    end
+
+  end
+end