shattered 0.5.0.1 → 0.7.0

data/lib/rails_generator/manifest.rb

@@ -1,53 +0,0 @@
-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

@@ -1,143 +0,0 @@
-require 'optparse'
-
-module Rails
-  module Generator
-    module Options
-      def self.included(base)
-        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(message = usage_message)
-          raise UsageError, "#{@option_parser}\n#{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 'Rails Info:'
-          opt.on('-v', '--version', 'Show the Rails version number and quit.')
-          opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
-
-          opt.separator ''
-          opt.separator 'General Options:'
-
-          opt.on('-p', '--pretend', 'Run but do not make any changes.') { |v| options[:pretend] = v }
-          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.') { |v| options[:quiet] = v }
-          opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |v| options[:backtrace] = v }
-          opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') do
-            options[:svn] = `svn status`.inject({}) do |opt, e|
-              opt[e.chomp[7..-1]] = true
-              opt
-            end
-          end
-        end
-
-    end
-  end
-end

data/lib/rails_generator/scripts.rb

@@ -1,83 +0,0 @@
-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} generator [options] [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 search -r generator
-  2. gem install login_generator
-  3. #{$0} login
-
-end_blurb
-            return usage
-          end
-      end # Base
-
-    end
-  end
-end

data/lib/rails_generator/scripts/destroy.rb

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

data/lib/rails_generator/scripts/generate.rb

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

data/lib/rails_generator/scripts/update.rb

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

data/lib/rails_generator/simple_logger.rb

@@ -1,46 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,7 +0,0 @@
-["shattered_support", "shattered_ogrerb", "shattered_pack"].each do |component|
-  lib_path = File.expand_path(File.dirname(__FILE__)+"/../../#{component}/lib")
-  $: << lib_path if File.directory? lib_path
-  require component
-end
-
-require File.dirname(__FILE__) + '/game_loader'

data/lib/tasks/documentation.rake

@@ -1,46 +0,0 @@
-namespace :doc do
-  desc "Generate documentation for the application"
-  Rake::RDocTask.new("app") { |rdoc|
-    rdoc.rdoc_dir = 'doc/app'
-    rdoc.title    = "Shattered Game Documentation"
-    rdoc.options << '--line-numbers' << '--inline-source'
-    rdoc.rdoc_files.include('doc/README_FOR_APP')
-    rdoc.rdoc_files.include('app/**/*.rb')
-  }
-  
-  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