shattered 0.3

data/lib/rails_generator/generators/applications/shattered_app/USAGE

@@ -0,0 +1,10 @@
+Description:
+    The 'shatter' command creates a new Shattered application with a default
+    directory structure and configuration at the path you specify.
+
+Example:
+    shatter ~/Code/Ruby/Quake15
+
+    This will create a skeletal Shattered application for the next version of
+    Quake. See the README in the newly created application to get going.
+

data/lib/rails_generator/generators/applications/shattered_app/shattered_app_generator.rb

@@ -0,0 +1,104 @@
+require 'rbconfig'
+
+class ShatteredAppGenerator < Rails::Generator::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options   :gem => true, :shebang => DEFAULT_SHEBANG
+  mandatory_options :source  => "#{File.dirname(__FILE__)}/../../../.."
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = args.shift
+  end
+
+  def manifest
+    script_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 "templates/Rakefile", "Rakefile"
+      m.file "templates/README",         "README"
+
+      # ogre plugins and configuration
+      m.template "templates/configs/plugins.cfg", "config/plugins.cfg"
+      m.template "templates/configs/plugins.linux.cfg", "config/plugins.linux.cfg"
+      m.template "templates/configs/plugins.darwin.cfg", "config/plugins.darwin.cfg"
+      m.template "templates/configs/plugins.win32.cfg", "config/plugins.win32.cfg"
+      m.template "templates/configs/ogre.cfg",    "config/ogre.cfg"
+      m.template "templates/configs/boot.rb",    "config/boot.rb"
+
+      # Environments
+      m.file "templates/environments/environment.rb", "config/environment.rb"
+      
+      # Mac OSX
+      m.file "templates/configs/Mac/shattered.app/Contents/Info.plist", "config/Mac/shattered.app/Contents/Info.plist"
+      m.file "templates/configs/Mac/shattered.app/Contents/MacOS/shattered_mac", "config/Mac/shattered.app/Contents/MacOS/shattered_mac"
+      m.file "templates/configs/Mac/shattered.app/Contents/pbdevelopment.plist", "config/Mac/shattered.app/Contents/pbdevelopment.plist"
+      m.file "templates/configs/Mac/shattered.app/Contents/PkgInfo", "config/Mac/shattered.app/Contents/PkgInfo"
+      m.file "templates/configs/Mac/shattered.app/Contents/Resources/English.lproj/InfoPlist.strings", "config/Mac/shattered.app/Contents/Resources/English.lproj/InfoPlist.strings"
+      m.file "templates/configs/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib/classes.nib", "config/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib/classes.nib"
+      m.file "templates/configs/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib/info.nib", "config/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib/info.nib"
+      m.file "templates/configs/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib/objects.nib", "config/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib/objects.nib"
+      m.file "templates/configs/Mac/shattered.app/Contents/Resources/rb_main.rb", "config/Mac/shattered.app/Contents/Resources/rb_main.rb"
+      
+      # Scripts
+      %w( generate runner console ).each do |file|
+        m.file "../bin/#{file}", "script/#{file}", script_options
+      end
+
+      m.file "templates/configs/runner.rb", "script/runner.rb"
+
+      # Docs
+      m.file "templates/doc/README_FOR_APP", "doc/README_FOR_APP"
+
+      # Logs
+      %w(ogre shattered).each { |file|
+        m.file "templates/configs/empty.log", "log/#{file}.log", :chmod => 0666
+      }
+      
+      # basic rmaterial
+      m.file "templates/media/basic.rmaterial", "media/templates/basic.rmaterial"
+      m.file "templates/media/offset_map.rmaterial", "media/templates/offset_map.rmaterial"
+    end
+  end
+
+  protected
+    def banner
+      "Usage: #{$0} /path/to/your/app [options]"
+    end
+
+    def add_options!(opt)
+      opt.separator ''
+      opt.separator 'Options:'
+      opt.on("--ruby [#{DEFAULT_SHEBANG}]",
+             "Path to the Ruby binary of your choice.") { |options[:shebang]| }
+      opt.on("--without-gems",
+             "Don't use the Shattered gems for your app.",
+             "This does not currently work.") { |options[:gem]| }
+    end
+
+
+  # Installation skeleton.  Intermediate directories are automatically
+  # created so don't sweat their absence here.
+  BASEDIRS = %w(
+    app/controllers
+    app/models
+    app/views
+    media/programs
+    media/templates
+    config/Mac/shattered.app/Contents/MacOS
+    config/Mac/shattered.app/Contents/Resources/English.lproj/MainMenu.nib
+    doc
+    log
+    script
+    test/unit
+    vendor
+    vendor/plugins
+  )
+end

data/lib/rails_generator/generators/components/actor/actor_generator.rb

@@ -0,0 +1,23 @@
+# require File.dirname(__FILE__) + '/../config/environment'
+# require 'rails_generator'
+# require 'rails_generator/scripts/generate'
+
+# ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+# Rails::Generator::Scripts::Generate.new.run(ARGV)
+require File.dirname(__FILE__) + '/../model/model_generator'
+require File.dirname(__FILE__) + '/../view/view_generator'
+require File.dirname(__FILE__) + '/../controller/controller_generator'
+
+class ActorGenerator < Rails::Generator::NamedBase
+ def manifest
+   model=["model", file_name]
+   view=["view", file_name]
+   controller=["controller", file_name]
+   Rails::Generator::Scripts::Generate.new.run(model)
+   Rails::Generator::Scripts::Generate.new.run(view)
+   Rails::Generator::Scripts::Generate.new.run(controller)
+      
+   record do |m|   
+   end
+ end
+end

data/lib/rails_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 app/controllers with view
+    templates in app/views/controller_name, a helper class in app/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: app/controllers/credit_card_controller.rb
+        Views:      app/views/credit_card/debit.rhtml [...]
+        Helper:     app/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: app/controllers/admin/credit_card_controller.rb
+        Views:      app/views/admin/credit_card/debit.rhtml [...]
+        Helper:     app/helpers/admin/credit_card_helper.rb
+        Test:       test/functional/admin/credit_card_controller_test.rb
+

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

@@ -0,0 +1,32 @@
+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('app/controllers', class_path)
+      #m.directory File.join('app/helpers', class_path)
+      #m.directory File.join('app/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('app/controllers',
+                            class_path,
+                            "#{file_name}_controller.rb")
+
+      # Functional tests are a good idea, but not yet encompassed
+#      m.template 'functional_test.rb',
+ #                 File.join('test/functional',
+  #                          class_path,
+   #                         "#{file_name}_controller_test.rb")
+
+#      m.template 'helper.rb',
+ #                 File.join('app/helpers',
+  #                          class_path,
+   #                         "#{file_name}_helper.rb")
+
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+class <%= class_name %>Controller < ShatteredController::Base
+  key :pressed => :w, :action => :move_forward
+  def move_forward
+  end
+end

data/lib/rails_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/rails_generator/generators/components/controller/templates/helper.rb

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

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

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

data/lib/rails_generator/generators/components/model/USAGE

@@ -0,0 +1,17 @@
+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 app/models, a test suite in
+    test/unit, and test fixtures in test/fixtures/singular_name.yml.
+
+Example:
+    ./script/generate model Account
+
+    This will create an Account model:
+        Model:      app/models/account.rb
+        Test:       test/unit/account_test.rb
+        Fixtures:   test/fixtures/accounts.yml
+

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

@@ -0,0 +1,17 @@
+class ModelGenerator < Rails::Generator::NamedBase
+  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('app/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('app/models', class_path, "#{file_name}_model.rb")
+      m.template 'unit_test.rb',  File.join('test/unit', class_path, "#{file_name}_test.rb")
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+first_<%= singular_name %>:
+  id: 1
+another_<%= singular_name %>:
+  id: 2

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

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

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

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

data/lib/rails_generator/generators/components/state/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 app/controllers with view
+    templates in app/views/controller_name, a helper class in app/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: app/controllers/credit_card_controller.rb
+        Views:      app/views/credit_card/debit.rhtml [...]
+        Helper:     app/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: app/controllers/admin/credit_card_controller.rb
+        Views:      app/views/admin/credit_card/debit.rhtml [...]
+        Helper:     app/helpers/admin/credit_card_helper.rb
+        Test:       test/functional/admin/credit_card_controller_test.rb
+

data/lib/rails_generator/generators/components/state/state_generator.rb

@@ -0,0 +1,19 @@
+class StateGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, "#{class_name}State"
+
+      # Controller, helper, views, and test directories.
+      m.directory File.join('app/states', class_path)
+
+      # Controller class, functional test, and helper class.
+      m.template 'state.rb',
+                  File.join('app/states',
+                            class_path,
+                            "#{file_name}_state.rb")
+
+
+    end
+  end
+end

data/lib/rails_generator/generators/components/state/templates/state.rb

@@ -0,0 +1,4 @@
+class <%= class_name %>State < ShatteredController::State
+  def update(time_elapsed)
+  end
+end

data/lib/rails_generator/generators/components/view/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 app/controllers with view
+    templates in app/views/controller_name, a helper class in app/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: app/controllers/credit_card_controller.rb
+        Views:      app/views/credit_card/debit.rhtml [...]
+        Helper:     app/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: app/controllers/admin/credit_card_controller.rb
+        Views:      app/views/admin/credit_card/debit.rhtml [...]
+        Helper:     app/helpers/admin/credit_card_helper.rb
+        Test:       test/functional/admin/credit_card_controller_test.rb
+

data/lib/rails_generator/generators/components/view/templates/material

@@ -0,0 +1,4 @@
+<%=class_name%>Material
+{
+
+}

data/lib/rails_generator/generators/components/view/templates/view.rb

@@ -0,0 +1,3 @@
+class <%= class_name %>View < ShatteredView::Base
+  mesh "<%= file_name %>"
+end

data/lib/rails_generator/generators/components/view/view_generator.rb

@@ -0,0 +1,18 @@
+class ViewGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, "#{class_name}View"
+
+      # Controller, helper, views, and test directories.
+      m.directory File.join('app/views', class_path)
+      m.directory File.join('app/views', class_path, file_name)
+
+      # Controller class, functional test, and helper class.
+      m.template 'view.rb',
+                  File.join('app/views',
+                            class_path,
+                            "#{file_name}_view.rb")
+    end
+  end
+end

data/lib/rails_generator/lookup.rb

@@ -0,0 +1,206 @@
+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 SHATTERED_ROOT/generators.
+    def lookup_missing_generator(class_id)
+      if md = /(.+)Generator$/.match(class_id.to_s)
+        name = md.captures.first.demodulize.underscore
+        Rails::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 Rails
+  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 SHATTERED_ROOT is defined we know we're
+        #     generating in the context of a Rails application, so search
+        #     SHATTERED_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
+          sources << PathSource.new(:app, "#{::SHATTERED_ROOT}/generators") if defined? ::SHATTERED_ROOT
+          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