shattered 0.3

data/lib/rails_generator/manifest.rb

@@ -0,0 +1,53 @@
+module Rails
+  module Generator
+
+    # Manifest captures the actions a generator performs.  Instantiate
+    # a manifest with an optional target object, hammer it with actions,
+    # then replay or rewind on the object of your choice.
+    #
+    # Example:
+    #   manifest = Manifest.new { |m|
+    #     m.make_directory '/foo'
+    #     m.create_file '/foo/bar.txt'
+    #   }
+    #   manifest.replay(creator)
+    #   manifest.rewind(destroyer)
+    class Manifest
+      attr_reader :target
+
+      # Take a default action target.  Yield self if block given.
+      def initialize(target = nil)
+        @target, @actions = target, []
+        yield self if block_given?
+      end
+
+      # Record an action.
+      def method_missing(action, *args, &block)
+        @actions << [action, args, block]
+      end
+
+      # Replay recorded actions.
+      def replay(target = nil)
+        send_actions(target || @target, @actions)
+      end
+
+      # Rewind recorded actions.
+      def rewind(target = nil)
+        send_actions(target || @target, @actions.reverse)
+      end
+
+      # Erase recorded actions.
+      def erase
+        @actions = []
+      end
+
+      private
+        def send_actions(target, actions)
+          actions.each do |method, args, block|
+            target.send(method, *args, &block)
+          end
+        end
+    end
+
+  end
+end

data/lib/rails_generator/options.rb

@@ -0,0 +1,135 @@
+require 'optparse'
+
+module Rails
+  module Generator
+    module Options
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        class << base
+          if respond_to?(:inherited)
+            alias_method :inherited_without_options, :inherited
+          end
+          alias_method :inherited, :inherited_with_options
+        end
+      end
+
+      module ClassMethods
+        def inherited_with_options(sub)
+          inherited_without_options(sub) if respond_to?(:inherited_without_options)
+          sub.extend(Rails::Generator::Options::ClassMethods)
+        end
+
+        def mandatory_options(options = nil)
+          if options
+            write_inheritable_attribute(:mandatory_options, options)
+          else
+            read_inheritable_attribute(:mandatory_options) or write_inheritable_attribute(:mandatory_options, {})
+          end
+        end
+
+        def default_options(options = nil)
+          if options
+            write_inheritable_attribute(:default_options, options)
+          else
+            read_inheritable_attribute(:default_options) or write_inheritable_attribute(:default_options, {})
+          end
+        end
+
+        # Merge together our class options.  In increasing precedence:
+        #   default_options   (class default options)
+        #   runtime_options   (provided as argument)
+        #   mandatory_options (class mandatory options)
+        def full_options(runtime_options = {})
+          default_options.merge(runtime_options).merge(mandatory_options)
+        end
+
+      end
+
+      # Each instance has an options hash that's populated by #parse.
+      def options
+        @options ||= {}
+      end
+      attr_writer :options
+
+      protected
+        # Convenient access to class mandatory options.
+        def mandatory_options
+          self.class.mandatory_options
+        end
+
+        # Convenient access to class default options.
+        def default_options
+          self.class.default_options
+        end
+
+        # Merge together our instance options.  In increasing precedence:
+        #   default_options   (class default options)
+        #   options           (instance options)
+        #   runtime_options   (provided as argument)
+        #   mandatory_options (class mandatory options)
+        def full_options(runtime_options = {})
+          self.class.full_options(options.merge(runtime_options))
+        end
+
+        # Parse arguments into the options hash.  Classes may customize
+        # parsing behavior by overriding these methods:
+        #   #banner                 Usage: ./script/generate [options]
+        #   #add_options!           Options:
+        #                             some options..
+        #   #add_general_options!   General Options:
+        #                             general options..
+        def parse!(args, runtime_options = {})
+          self.options = {}
+
+          @option_parser = OptionParser.new do |opt|
+            opt.banner = banner
+            add_options!(opt)
+            add_general_options!(opt)
+            opt.parse!(args)
+          end
+
+          return args
+        ensure
+          self.options = full_options(runtime_options)
+        end
+
+        # Raise a usage error.  Override usage_message to provide a blurb
+        # after the option parser summary.
+        def usage
+          raise UsageError, "#{@option_parser}\n#{usage_message}"
+        end
+
+        def usage_message
+          ''
+        end
+
+        # Override with your own usage banner.
+        def banner
+          "Usage: #{$0} [options]"
+        end
+
+        # Override to add your options to the parser:
+        #   def add_options!(opt)
+        #     opt.on('-v', '--verbose') { |value| options[:verbose] = value }
+        #   end
+        def add_options!(opt)
+        end
+
+        # Adds general options like -h and --quiet.  Usually don't override.
+        def add_general_options!(opt)
+          opt.separator ''
+          opt.separator 'General Options:'
+
+          opt.on('-p', '--pretend', 'Run but do not make any changes.') { |options[:pretend]| }
+          opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
+          opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
+          opt.on('-q', '--quiet', 'Suppress normal output.') { |options[:quiet]| }
+          opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |options[:backtrace]| }
+          opt.on('-h', '--help', 'Show this help message.') { |options[:help]| }
+          opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') { options[:svn] = Hash[*`svn status`.collect { |e| e.chop.split.reverse unless e.chop.split.size != 2 }.flatten] }
+        end
+
+    end
+  end
+end

data/lib/rails_generator/scripts.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/options'
+
+module Rails
+  module Generator
+    module Scripts
+
+      # Generator scripts handle command-line invocation.  Each script
+      # responds to an invoke! class method which handles option parsing
+      # and generator invocation.
+      class Base
+        include Options
+        default_options :collision => :ask, :quiet => false
+
+        # Run the generator script.  Takes an array of unparsed arguments
+        # and a hash of parsed arguments, takes the generator as an option
+        # or first remaining argument, and invokes the requested command.
+        def run(args = [], runtime_options = {})
+          begin
+            parse!(args.dup, runtime_options)
+          rescue OptionParser::InvalidOption => e
+            # Don't cry, script. Generators want what you think is invalid.
+          end
+
+          # Generator name is the only required option.
+          unless options[:generator]
+            usage if args.empty?
+            options[:generator] ||= args.shift
+          end
+
+          # Look up generator instance and invoke command on it.
+          Rails::Generator::Base.instance(options[:generator], args, options).command(options[:command]).invoke!
+        rescue => e
+          puts e
+          puts "  #{e.backtrace.join("\n  ")}\n" if options[:backtrace]
+          raise SystemExit
+        end
+
+        protected
+          # Override with your own script usage banner.
+          def banner
+            "Usage: #{$0} [options] generator [args]"
+          end
+
+          def usage_message
+            usage = "\nInstalled Generators\n"
+            Rails::Generator::Base.sources.each do |source|
+              label = source.label.to_s.capitalize
+              names = source.names
+              usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
+            end
+
+            usage << <<end_blurb
+
+More are available at http://rubyonrails.org/show/Generators
+  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
+end_blurb
+
+            if Object.const_defined?(:SHATTERED_ROOT)
+              usage << <<end_blurb
+     or to #{File.expand_path(SHATTERED_ROOT)}/generators/login
+     to use with this app only.
+end_blurb
+            end
+
+            usage << <<end_blurb
+  3. Run generate with no arguments for usage information
+       #{$0} login
+
+Generator gems are also available:
+  1. gem list generator -s http://gems.rubyonrails.org
+  2. gem install login_generator -s http://gems.rubyonrails.org
+  3. #{$0} login
+
+end_blurb
+            return usage
+          end
+      end # Base
+
+    end
+  end
+end

data/lib/rails_generator/scripts/destroy.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module Rails::Generator::Scripts
+  class Destroy < Base
+    mandatory_options :command => :destroy
+  end
+end

data/lib/rails_generator/scripts/generate.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module Rails::Generator::Scripts
+  class Generate < Base
+    mandatory_options :command => :create
+  end
+end

data/lib/rails_generator/scripts/update.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../scripts'
+
+module Rails::Generator::Scripts
+  class Update < Base
+    mandatory_options :command => :update
+
+    protected
+      def banner
+        "Usage: #{$0} [options] scaffold"
+      end
+  end
+end

data/lib/rails_generator/simple_logger.rb

@@ -0,0 +1,46 @@
+module Rails
+  module Generator
+    class SimpleLogger # :nodoc:
+      attr_reader :out
+      attr_accessor :quiet
+
+      def initialize(out = $stdout)
+        @out = out
+        @quiet = false
+        @level = 0
+      end
+
+      def log(status, message, &block)
+        @out.print("%12s  %s%s\n" % [status, '  ' * @level, message]) unless quiet
+        indent(&block) if block_given?
+      end
+
+      def indent(&block)
+        @level += 1
+        if block_given?
+          begin
+            block.call
+          ensure
+            outdent
+          end
+        end
+      end
+
+      def outdent
+        @level -= 1
+        if block_given?
+          begin
+            block.call
+          ensure
+            indent
+          end
+        end
+      end
+
+      private
+        def method_missing(method, *args, &block)
+          log(method.to_s, args.first, &block)
+        end
+    end
+  end
+end

data/lib/rails_generator/spec.rb

@@ -0,0 +1,44 @@
+module Rails
+  module Generator
+    # A spec knows where a generator was found and how to instantiate it.
+    # Metadata include the generator's name, its base path, and the source
+    # which yielded it (PathSource, GemSource, etc.)
+    class Spec
+      attr_reader :name, :path, :source
+
+      def initialize(name, path, source)
+        @name, @path, @source = name, path, source
+      end
+
+      # Look up the generator class.  Require its class file, find the class
+      # in ObjectSpace, tag it with this spec, and return.
+      def klass
+        unless @klass
+          require class_file
+          @klass = lookup_class
+          @klass.spec = self
+        end
+        @klass
+      end
+
+      def class_file
+        "#{path}/#{name}_generator.rb"
+      end
+
+      def class_name
+        "#{name.camelize}Generator"
+      end
+
+      private
+        # Search for the first Class descending from Rails::Generator::Base
+        # whose name matches the requested class name.
+        def lookup_class
+          ObjectSpace.each_object(Class) do |obj|
+            return obj if obj.ancestors.include?(Rails::Generator::Base) and
+                          obj.name.split('::').last == class_name
+          end
+          raise NameError, "Missing #{class_name} class in #{class_file}"
+        end
+    end
+  end
+end

data/lib/shatter.rb

@@ -0,0 +1,11 @@
+["shattered_model", "shattered_view","shattered_controller"].each do |component|
+  begin
+#    require File.dirname(__FILE__) + "/../../#{component}/lib/#{component}"
+    require component
+  rescue MissingSourceFile
+    require 'rubygems'
+    require component
+  end
+end
+
+require File.dirname(__FILE__) + '/game_loader'

data/lib/templates/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2004 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/templates/README

@@ -0,0 +1,35 @@
+== Description of contents
+
+A large part of this is inspired (cp -R) by Rails.  The fact that a web framework and a game framework have so much in common amazes me.
+
+Each project is created with the following directory structure:
+
+log/
+	Ogre.log - For Ogre's errors
+	Shattered.log - For all of shattered's messages
+
+test/
+	Anything that matches /.*_test.rb/ will be executed when testing.
+
+app/
+	models/
+		All models here.
+	controllers/
+		All model controllers(AI, keyboard) here.
+	views/	
+		The views are here, each with a corresponding directory.
+		puppy_view.rb
+		puppy/
+				puppy.mesh
+				puppy.skeleton
+				puppy.material
+				puppy.png
+				puppy_normals.png
+		
+config/
+	Here you will define the ogre and other configuration
+
+script/
+	This contains the generators/runners/executable scripts
+doc/
+	The documentation in this directory will be generated by rails rdoc.