shattered 0.5.0.1 → 0.7.0

data/bin/runner

@@ -1,9 +0,0 @@
-#!/usr/local/bin/ruby
-
-if PLATFORM =~ /powerpc-darwin/
-	path = File.dirname(__FILE__) + "/../config/Mac/"
-	puts `(cd #{path}shattered.app; ./Contents/MacOS/shattered_mac)`
-else
-	require File.dirname(__FILE__)+'/runner'
-	start_game
-end

data/bin/shatter

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby 
-#This file is adapted from the rails command.
-
-min_release  = "1.8.2 (2004-12-25)"
-ruby_release = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
-
-if ruby_release < min_release
-  abort <<-end_message
-
-    Shattered requires Ruby version #{min_release} or later.
-    You're running #{ruby_release}; please upgrade to continue.
-
-  end_message
-end
-
-Signal.trap("INT") { puts; exit }
-
-
-require File.dirname(__FILE__) + '/../lib/rails_generator'
-require 'rails_generator/scripts/generate'
-Rails::Generator::Base.use_application_sources!
-Rails::Generator::Scripts::Generate.new.run(ARGV, :generator => 'shattered_app')

data/lib/commands/console.rb

@@ -1,23 +0,0 @@
-irb = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
-
-require 'optparse'
-options = { :sandbox => false, :irb => irb }
-OptionParser.new do |opt|
-	opt.banner = "Usage: console [environment] [options]"
-  opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |options[:sandbox]| }
-  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |options[:irb]| }
-  opt.parse!(ARGV)
-end
-
-libs =  " -r irb/completion"
-libs << " -r #{SHATTERED_ROOT}/config/environment"
-libs << " -r console_sandbox" if options[:sandbox]
-
-ENV['SHATTERED_ENV'] = ARGV.first || ENV['SHATTERED_ENV'] || 'development'
-if options[:sandbox]
-  puts "Loading #{ENV['SHATTER_ENV']} environment in sandbox."
-  puts "Any modifications you make will be rolled back on exit."
-else
-  puts "Loading #{ENV['SHATTER_ENV']} environment."
-end
-exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/game_loader.rb

@@ -1,118 +0,0 @@
-require 'singleton'
-
-include ShatteredState
-include ShatteredView
-include ShatteredModel
-
-module Shatter #:nodoc:all
-#This class is loads the view, controller, and model.  It then loads
-#and starts the game based on these.
-class GameLoader
-	include Singleton
-	attr_writer :environment
-	attr_reader :media_paths, :render_window, :input_manager, :key_manager, :key_converter
-	attr_accessor :current_state
-	
-	# This will recourse into the app/** directories and load all ruby files 
-	# inside those directories.
-  def load_all_sources(shattered_root)
-    File.find_by_extension(shattered_root+"/app", "rb").each do |file|
-      require(file)
-    end
-  end
-  
-  # start the game
-	def run
-		load_all_sources(SHATTERED_ROOT)
-		load_environment
-		
-		# Create our initial state, as defined by the environment.
-		create_state(@environment[:start_state])
-
-		start_game
-	end
-	
-	# Create a state from the given name
-	# :sample creates a new SampleState object
-	def create_state(state_name)
-		state_class = eval("#{state_name.to_s.camelize}State")
-		raise Error, "#{state_class} is not a class" unless state_class.is_a? Class
-		state = state_class.new
-		unless state.is_a? ShatteredState::Base
-			raise Error, "#{state_class} is an invalid State object (not of ShatteredState::Base)" 
-		end
-		return state
-	end
-	
-	def load_environment
-	  #Setup Ogre and the scene for the state
-    raise Error, "Ogre failed to initialize" if !setup_ogre
-		setup_input
-
-		load_resources(@environment[:media])
-	end
-
-	# Given ['app/media', 'media'], searches those directories, recursively, for OGRE media
-  def load_resources(paths)
-  	@media_paths = paths
-  	# setup our resource paths specified in environment.rb
-    Resources.instance.add_resource_paths(*paths)
-    Resources.instance.setup
-	end    
-	
-	#Load the root, setup the render window
-  #TODO: allow for the user to specify whether the window dialogue pops up
-  #further TODO: allow the user to skin the render window dialogue
-  def setup_ogre
-  	# TODO: create platform loader for other platforms
-  	plugins = SHATTERED_ROOT + "/config/ogre_plugins.windows.cfg"
-  	config_save=SHATTERED_ROOT + "/config/ogrerb_defaults.save"
-  	log=SHATTERED_ROOT + "/log/ogrerb.log"
-  	@root = ShatteredOgre.create_root(plugins, config_save, log)
-  	return false if !@root.show_config_dialog
-  	# TODO: allow application name to be set.
-  	@render_window = @root.initialise(true)
-  	
-  	return true
-  end  
-  
-  #Every time this exits, a game dies.
-  def start_game
-    each_frame do |time_elapsed|
-      current_state.update_timers(time_elapsed)
-      @keyboard.capture
-      #@@environment[:input].flush
-    end
-  end
-
-	# Main game loop
-  def each_frame
-  	timer = Ogre::Timer.new
-    while !@environment[:quit] && Ogre::Root::instance.render_one_frame
-    	seconds = timer.get_microseconds / 1000000.0
-	    yield seconds
-      timer.reset
-		end
-	end
-	
-	# Leave the game
-	def quit!
-		@environment[:quit]=true
-	end
-	
-	# load the input manager, the key manager, etc
-	# TODO: Consider how to make input non-exclusive, as well as mouse, etc.
-	# TODO: Investigate any use cases for non-buffered input
-	def setup_input
-		windowHnd = render_window.get_custom_attribute_unsigned_long("WINDOW")
-		@input_manager = OIS::InputManager.create_input_system(
-	{  "WINDOW" => "#{windowHnd}",
-		 "w32_mouse" => ["DISCL_FOREGROUND", "DISCL_NONEXCLUSIVE"],
-		 "w32_keyboard" => ["DISCL_FOREGROUND", "DISCL_NONEXCLUSIVE"]
-	})
-		@keyboard = @input_manager.create_input_object(OIS::OISKeyboard, true)
-		@key_manager = OIS::KeyManager.new(@keyboard)
-		@key_converter = ShatteredPack::KeyConverter.new(@key_manager)
-	end
-end
-end

data/lib/rails_generator.rb

@@ -1,43 +0,0 @@
-#--
-# Copyright (c) 2004 Jeremy Kemper
-#
-# 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.
-#++
-
-$:.unshift(File.dirname(__FILE__))
-$:.unshift(File.dirname(__FILE__) + "/../../shattered_support/lib")
-
-begin
-  require 'shattered_support'  
-rescue LoadError
-  require 'rubygems'
-  require_gem 'shattered_support'
-end
-
-require 'rails_generator/base'
-require 'rails_generator/lookup'
-require 'rails_generator/commands'
-
-Rails::Generator::Base.send(:include, Rails::Generator::Lookup)
-Rails::Generator::Base.send(:include, Rails::Generator::Commands)
-
-# Set up a default logger for convenience.
-require 'rails_generator/simple_logger'
-Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(STDOUT)

data/lib/rails_generator/base.rb

@@ -1,203 +0,0 @@
-require File.dirname(__FILE__) + '/options'
-require File.dirname(__FILE__) + '/manifest'
-require File.dirname(__FILE__) + '/spec'
-
-# Rails::Generator is a code generation platform tailored for the Rails
-# web application framework.  Generators are easily invoked within Rails
-# applications to add and remove components such as models and controllers.
-# New generators are easy to create and may be distributed as RubyGems or
-# tarballs for inclusion system-wide, per-user, or per-application.
-#
-# Generators may subclass other generators to provide variations that
-# require little or no new logic but replace the template files.
-# The postback generator is an example:  it subclasses the scaffold
-# generator and just replaces the code templates with its own.
-#
-# Now go forth and multiply^Wgenerate.
-module Rails
-  module Generator
-    class GeneratorError < StandardError; end
-    class UsageError < GeneratorError; end
-
-
-    # The base code generator is bare-bones.  It sets up the source and
-    # destination paths and tells the logger whether to keep its trap shut.
-    # You're probably looking for NamedBase, a subclass meant for generating
-    # "named" components such as models, controllers, and mailers.
-    #
-    # Generators create a manifest of the actions they perform then hand
-    # the manifest to a command which replay the actions to do the heavy
-    # lifting.  Create, destroy, and list commands are included.  Since a
-    # single manifest may be used by any command, creating new generators is
-    # as simple as writing some code templates and declaring what you'd like
-    # to do with them.
-    #
-    # The manifest method must be implemented by subclasses, returning a
-    # Rails::Generator::Manifest.  The record method is provided as a
-    # convenience for manifest creation.  Example:
-    #   class EliteGenerator < Rails::Generator::Base
-    #     def manifest
-    #       record do |m|
-    #         m.do(some)
-    #         m.things(in) { here }
-    #       end
-    #     end
-    #   end
-    class Base
-      include Options
-
-      # Declare default options for the generator.  These options
-      # are inherited to subclasses.
-      default_options :collision => :ask, :quiet => false
-
-      # A logger instance available everywhere in the generator.
-      cattr_accessor :logger
-
-      # Every generator that is dynamically looked up is tagged with a
-      # Spec describing where it was found.
-      class_inheritable_accessor :spec
-
-      attr_reader :source_root, :destination_root, :args
-
-      def initialize(runtime_args, runtime_options = {})
-        @args = runtime_args
-        parse!(@args, runtime_options)
-
-        # Derive source and destination paths.
-        @source_root = options[:source] || File.join(spec.path, 'templates')
-        if options[:destination]
-          @destination_root = options[:destination]
-        elsif defined? ::SHATTERED_ROOT
-          @destination_root = ::SHATTERED_ROOT
-        end
-
-        # Silence the logger if requested.
-        logger.quiet = options[:quiet]
-
-        # Raise usage error if help is requested.
-        usage if options[:help]
-      end
-
-      # Generators must provide a manifest.  Use the record method to create
-      # a new manifest and record your generator's actions.
-      def manifest
-        raise NotImplementedError, "No manifest for '#{spec.name}' generator."
-      end
-
-      # Return the full path from the source root for the given path.
-      # Example for source_root = '/source':
-      #   source_path('some/path.rb') == '/source/some/path.rb'
-      #
-      # The given path may include a colon ':' character to indicate that
-      # the file belongs to another generator.  This notation allows any
-      # generator to borrow files from another.  Example:
-      #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
-      def source_path(relative_source)
-        # Check whether we're referring to another generator's file.
-        name, path = relative_source.split(':', 2)
-
-        # If not, return the full path to our source file.
-        if path.nil?
-          File.join(source_root, name)
-
-        # Otherwise, ask our referral for the file.
-        else
-          # FIXME: this is broken, though almost always true.  Others'
-          # source_root are not necessarily the templates dir.
-          File.join(self.class.lookup(name).path, 'templates', path)
-        end
-      end
-
-      # Return the full path from the destination root for the given path.
-      # Example for destination_root = '/dest':
-      #   destination_path('some/path.rb') == '/dest/some/path.rb'
-      def destination_path(relative_destination)
-        File.join(destination_root, relative_destination)
-      end
-
-      protected
-        # Convenience method for generator subclasses to record a manifest.
-        def record
-          Rails::Generator::Manifest.new(self) { |m| yield m }
-        end
-
-        # Override with your own usage banner.
-        def banner
-          "Usage: #{$0} #{spec.name} [options]"
-        end
-
-        # Read USAGE from file in generator base path.
-        def usage_message
-          File.read(File.join(spec.path, 'USAGE')) rescue ''
-        end
-    end
-
-
-    # The base generator for named components: models, controllers, mailers,
-    # etc.  The target name is taken as the first argument and inflected to
-    # singular, plural, class, file, and table forms for your convenience.
-    # The remaining arguments are aliased to actions for controller and
-    # mailer convenience.
-    #
-    # 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.
-    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
-      alias_method  :file_name,  :singular_name
-      alias_method  :actions, :args
-
-      def initialize(runtime_args, runtime_options = {})
-        super
-
-        # Name argument is required.
-        usage if runtime_args.empty?
-
-        @args = runtime_args.dup
-        base_name = @args.shift
-        assign_names!(base_name)
-      end
-
-      protected
-        # Override with your own usage banner.
-        def banner
-          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
-        end
-
-      private
-        def assign_names!(name)
-          @name = name
-          base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
-          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
-          @table_name = singular_name
-          if @class_nesting.empty?
-            @class_name = @class_name_without_nesting
-          else
-            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
-          end
-        end
-
-        # Extract modules from filesystem-style or ruby-style path:
-        #   good/fun/stuff
-        #   Good::Fun::Stuff
-        # produce the same results.
-        def extract_modules(name)
-          modules = name.include?('/') ? name.split('/') : name.split('::')
-          name    = modules.pop
-          path    = modules.map { |m| m.underscore }
-          file_path = (path + [name.underscore]).join('/')
-          nesting = modules.map { |m| m.camelize }.join('::')
-          [name, path, file_path, nesting, modules.size]
-        end
-
-        def inflect_names(name)
-          camel  = name.camelize
-          under  = camel.underscore
-          plural = under.pluralize
-          [camel, under, plural]
-        end
-    end
-  end
-end

data/lib/rails_generator/commands.rb

@@ -1,519 +0,0 @@
-require 'delegate'
-require 'optparse'
-require 'fileutils'
-require 'erb'
-
-module Rails
-  module Generator
-    module Commands
-      # Here's a convenient way to get a handle on generator commands.
-      # Command.instance('destroy', my_generator) instantiates a Destroy
-      # delegate of my_generator ready to do your dirty work.
-      def self.instance(command, generator)
-        const_get(command.to_s.camelize).new(generator)
-      end
-
-      # Even more convenient access to commands.  Include Commands in
-      # the generator Base class to get a nice #command instance method
-      # which returns a delegate for the requested command.
-      def self.included(base)
-        base.send(:define_method, :command) do |command|
-          Commands.instance(command, self)
-        end
-      end
-
-
-      # Generator commands delegate Rails::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
-      # are required to override.
-      #
-      # Commands allows generators to "plug in" invocation behavior, which
-      # corresponds to the GoF Strategy pattern.
-      class Base < DelegateClass(Rails::Generator::Base)
-        # Replay action manifest.  RewindBase subclass rewinds manifest.
-        def invoke!
-          manifest.replay(self)
-        end
-
-        def dependency(generator_name, args, runtime_options = {})
-          logger.dependency(generator_name) do
-            self.class.new(instance(generator_name, args, full_options(runtime_options))).invoke!
-          end
-        end
-
-        # Does nothing for all commands except Create.
-        def class_collisions(*class_names)
-        end
-
-        # Does nothing for all commands except Create.
-        def readme(*args)
-        end
-
-        protected
-          def migration_directory(relative_path)
-            directory(@migration_directory = relative_path)
-          end
-
-          def existing_migrations(file_name)
-            Dir.glob("#{@migration_directory}/[0-9]*_*.rb").grep(/[0-9]+_#{file_name}.rb$/)
-          end
-
-          def migration_exists?(file_name)
-            not existing_migrations(file_name).empty?
-          end
-
-          def current_migration_number
-            Dir.glob("#{@migration_directory}/[0-9]*.rb").inject(0) do |max, file_path|
-              n = File.basename(file_path).split('_', 2).first.to_i
-              if n > max then n else max end
-            end
-          end
-
-          def next_migration_number
-            current_migration_number + 1
-          end
-
-          def next_migration_string(padding = 3)
-            "%.#{padding}d" % next_migration_number
-          end
-
-        private
-          # Ask the user interactively whether to force collision.
-          def force_file_collision?(destination)
-            $stdout.print "overwrite #{destination}? [Ynaq] "
-            case $stdin.gets
-              when /a/i
-                $stdout.puts "forcing #{spec.name}"
-                options[:collision] = :force
-              when /q/i
-                $stdout.puts "aborting #{spec.name}"
-                raise SystemExit
-              when /n/i then :skip
-              else :force
-            end
-          rescue
-            retry
-          end
-
-          def render_template_part(template_options)
-            # Getting Sandbox to evaluate part template in it
-            part_binding = template_options[:sandbox].call.sandbox_binding
-            part_rel_path = template_options[:insert]
-            part_path = source_path(part_rel_path)
-
-            # Render inner template within Sandbox binding
-            rendered_part = ERB.new(File.readlines(part_path).join, nil, '-').result(part_binding)
-            begin_mark = template_part_mark(template_options[:begin_mark], template_options[:mark_id])
-            end_mark = template_part_mark(template_options[:end_mark], template_options[:mark_id])
-            begin_mark + rendered_part + end_mark
-          end
-
-          def template_part_mark(name, id)
-            "<!--[#{name}:#{id}]-->\n"
-          end
-      end
-
-      # Base class for commands which handle generator actions in reverse, such as Destroy.
-      class RewindBase < Base
-        # Rewind action manifest.
-        def invoke!
-          manifest.rewind(self)
-        end
-      end
-
-
-      # Create is the premier generator command.  It copies files, creates
-      # directories, renders templates, and more.
-      class Create < Base
-
-        # Check whether the given class names are already taken by
-        # Ruby or Rails.  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|
-            # Convert to string to allow symbol arguments.
-            class_name = class_name.to_s
-
-            # Skip empty strings.
-            next if class_name.strip.empty?
-
-            # Split the class from its module nesting.
-            nesting = class_name.split('::')
-            name = nesting.pop
-
-            # Extract the last Module in the nesting.
-            last = nesting.inject(Object) { |last, nest|
-              break unless last.const_defined?(nest)
-              last.const_get(nest)
-            }
-
-            # If the last Module exists, check whether the given
-            # class exists and raise a collision if so.
-            if last and last.const_defined?(name.camelize)
-              raise_class_collision(class_name)
-            end
-          end
-        end
-
-        # Copy a file from source to destination with collision checking.
-        #
-        # The file_options hash accepts :chmod and :shebang and :collision options.
-        # :chmod sets the permissions of the destination file:
-        #   file 'config/empty.log', 'log/test.log', :chmod => 0664
-        # :shebang sets the #!/usr/bin/ruby line for scripts
-        #   file 'bin/generate.rb', 'script/generate', :chmod => 0755, :shebang => '/usr/bin/env ruby'
-        # :collision sets the collision option only for the destination file: 
-        #   file 'settings/server.yml', 'config/server.yml', :collision => :skip
-        #
-        # Collisions are handled by checking whether the destination file
-        # exists and either skipping the file, forcing overwrite, or asking
-        # the user what to do.
-        def file(relative_source, relative_destination, file_options = {}, &block)
-          # Determine full paths for source and destination files.
-          source              = source_path(relative_source)
-          destination         = destination_path(relative_destination)
-          destination_exists  = File.exists?(destination)
-
-          # If source and destination are identical then we're done.
-          if destination_exists and identical?(source, destination, &block)
-            return logger.identical(relative_destination) 
-          end
-
-          # Check for and resolve file collisions.
-          if destination_exists
-
-            # Make a choice whether to overwrite the file.  :force and
-            # :skip already have their mind made up, but give :ask a shot.
-            choice = case (file_options[:collision] || options[:collision]).to_sym #|| :ask
-              when :ask   then force_file_collision?(relative_destination)
-              when :force then :force
-              when :skip  then :skip
-              else raise "Invalid collision option: #{options[:collision].inspect}"
-            end
-
-            # Take action based on our choice.  Bail out if we chose to
-            # skip the file; otherwise, log our transgression and continue.
-            case choice
-              when :force then logger.force(relative_destination)
-              when :skip  then return(logger.skip(relative_destination))
-              else raise "Invalid collision choice: #{choice}.inspect"
-            end
-
-          # File doesn't exist so log its unbesmirched creation.
-          else
-            logger.create relative_destination
-          end
-
-          # If we're pretending, back off now.
-          return if options[:pretend]
-
-          # Write destination file with optional shebang.  Yield for content
-          # if block given so templaters may render the source file.  If a
-          # shebang is requested, replace the existing shebang or insert a
-          # new one.
-          File.open(destination, 'wb') do |df|
-            File.open(source, 'rb') do |sf|
-              if block_given?
-                df.write(yield(sf))
-              else
-                if file_options[:shebang]
-                  df.puts("#!#{file_options[:shebang]}")
-                  if line = sf.gets
-                    df.puts(line) if line !~ /^#!/
-                  end
-                end
-                df.write(sf.read)
-              end
-            end
-          end
-
-          # Optionally change permissions.
-          if file_options[:chmod]
-            FileUtils.chmod(file_options[:chmod], destination)
-          end
-          
-          # Optionally add file to subversion
-          system("svn add #{destination}") if options[:svn]
-        end
-
-        # Checks if the source and the destination file are identical. If
-        # passed a block then the source file is a template that needs to first
-        # be evaluated before being compared to the destination.
-        def identical?(source, destination, &block)
-          return false if File.directory? destination
-          source      = block_given? ? File.open(source) {|sf| yield(sf)} : IO.read(source)
-          destination = IO.read(destination)
-          source == destination
-        end
-
-        # Generate a file for a Rails 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
-        # proliferation of whitespace in generated code.  <%- trims leading
-        # whitespace; -%> trims trailing whitespace including one newline.
-        #
-        # A hash of template options may be passed as the last argument.
-        # The options accepted by the file are accepted as well as :assigns,
-        # a hash of variable bindings.  Example:
-        #   template 'foo', 'bar', :assigns => { :action => 'view' }
-        #
-        # Template is implemented in terms of file.  It calls file with a
-        # block which takes a file handle and returns its rendered contents.
-        def template(relative_source, relative_destination, template_options = {})
-          file(relative_source, relative_destination, template_options) do |file|
-            # Evaluate any assignments in a temporary, throwaway binding.
-            vars = template_options[:assigns] || {}
-            b = binding
-            vars.each { |k,v| eval "#{k} = vars[:#{k}] || vars['#{k}']", b }
-
-            # Render the source file with the temporary binding.
-            ERB.new(file.read, nil, '-').result(b)
-          end
-        end
-
-        def complex_template(relative_source, relative_destination, template_options = {})
-          options = template_options.dup
-          options[:assigns] ||= {}
-          options[:assigns]['template_for_inclusion'] = render_template_part(template_options)
-          template(relative_source, relative_destination, options)
-        end
-
-        # Create a directory including any missing parent directories.
-        # Always directories which exist.
-        def directory(relative_path)
-          path = destination_path(relative_path)
-          if File.exists?(path)
-            logger.exists relative_path
-          else
-            logger.create relative_path
-            FileUtils.mkdir_p(path) unless options[:pretend]
-            
-            # Optionally add file to subversion
-            system("svn add #{path}") if options[:svn]
-          end
-        end
-
-        # Display a README.
-        def readme(*relative_sources)
-          relative_sources.flatten.each do |relative_source|
-            logger.readme relative_source
-            puts File.read(source_path(relative_source)) unless options[:pretend]
-          end
-        end
-
-        # When creating a migration, it knows to find the first available file in db/migrate and use the migration.rb template.
-        def migration_template(relative_source, relative_destination, template_options = {})
-          migration_directory relative_destination
-          migration_file_name = template_options[:migration_file_name] || file_name
-          raise "Another migration is already named #{migration_file_name}: #{existing_migrations(migration_file_name).first}" if migration_exists?(migration_file_name)
-          template(relative_source, "#{relative_destination}/#{next_migration_string}_#{migration_file_name}.rb", template_options)
-        end
-
-        private
-          # Raise a usage error with an informative WordNet suggestion.
-          # Thanks to Florian Gross (flgr).
-          def raise_class_collision(class_name)
-            message = <<end_message
-  The name '#{class_name}' is reserved by Ruby on Rails.
-  Please choose an alternative and run this generator again.
-end_message
-            if suggest = find_synonyms(class_name)
-              message << "\n  Suggestions:  \n\n"
-              message << suggest.join("\n")
-            end
-            raise UsageError, message
-          end
-
-          SYNONYM_LOOKUP_URI = "http://wordnet.princeton.edu/cgi-bin/webwn2.0?stage=2&word=%s&posnumber=1&searchtypenumber=2&senses=&showglosses=1"
-
-          # Look up synonyms on WordNet.  Thanks to Florian Gross (flgr).
-          def find_synonyms(word)
-            require 'open-uri'
-            require 'timeout'
-            timeout(5) do
-              open(SYNONYM_LOOKUP_URI % word) do |stream|
-                data = stream.read.gsub("&nbsp;", " ").gsub("<BR>", "")
-                data.scan(/^Sense \d+\n.+?\n\n/m)
-              end
-            end
-          rescue Exception
-            return nil
-          end
-      end
-
-
-      # Undo the actions performed by a generator.  Rewind the action
-      # manifest and attempt to completely erase the results of each action.
-      class Destroy < RewindBase
-        # Remove a file if it exists and is a file.
-        def file(relative_source, relative_destination, file_options = {})
-          destination = destination_path(relative_destination)
-          if File.exists?(destination)
-            logger.rm relative_destination
-            unless options[:pretend]
-              if options[:svn]
-                # If the file has been marked to be added
-                # but has not yet been checked in, revert and delete
-                if options[:svn][relative_destination]
-                  system("svn revert #{destination}")
-                  FileUtils.rm(destination)
-                else
-                # If the directory is not in the status list, it
-                # has no modifications so we can simply remove it
-                  system("svn rm #{destination}")
-                end  
-              else
-                FileUtils.rm(destination)
-              end
-            end
-          else
-            logger.missing relative_destination
-            return
-          end
-        end
-
-        # Templates are deleted just like files and the actions take the
-        # same parameters, so simply alias the file method.
-        alias_method :template, :file
-
-        # Remove each directory in the given path from right to left.
-        # Remove each subdirectory if it exists and is a directory.
-        def directory(relative_path)
-          parts = relative_path.split('/')
-          until parts.empty?
-            partial = File.join(parts)
-            path = destination_path(partial)
-            if File.exists?(path)
-              if Dir[File.join(path, '*')].empty?
-                logger.rmdir partial
-                unless options[:pretend]
-                  if options[:svn]
-                    # If the directory has been marked to be added
-                    # but has not yet been checked in, revert and delete
-                    if options[:svn][relative_path]
-                      system("svn revert #{path}")
-                      FileUtils.rmdir(path)
-                    else
-                    # If the directory is not in the status list, it
-                    # has no modifications so we can simply remove it
-                      system("svn rm #{path}")
-                    end
-                  else
-                    FileUtils.rmdir(path)
-                  end
-                end
-              else
-                logger.notempty partial
-              end
-            else
-              logger.missing partial
-            end
-            parts.pop
-          end
-        end
-
-        def complex_template(*args)
-          # nothing should be done here
-        end
-
-        # When deleting a migration, it knows to delete every file named "[0-9]*_#{file_name}".
-        def migration_template(relative_source, relative_destination, template_options = {})
-          migration_directory relative_destination
-
-          migration_file_name = template_options[:migration_file_name] || file_name
-          unless migration_exists?(migration_file_name)
-            puts "There is no migration named #{migration_file_name}"
-            return
-          end
-
-
-          existing_migrations(migration_file_name).each do |file_path|
-            file(relative_source, file_path, template_options)
-          end
-        end
-      end
-
-
-      # List a generator's action manifest.
-      class List < Base
-        def dependency(generator_name, args, options = {})
-          logger.dependency "#{generator_name}(#{args.join(', ')}, #{options.inspect})"
-        end
-
-        def class_collisions(*class_names)
-          logger.class_collisions class_names.join(', ')
-        end
-
-        def file(relative_source, relative_destination, options = {})
-          logger.file relative_destination
-        end
-
-        def template(relative_source, relative_destination, options = {})
-          logger.template relative_destination
-        end
-
-        def complex_template(relative_source, relative_destination, options = {})
-          logger.template "#{options[:insert]} inside #{relative_destination}"
-        end
-
-        def directory(relative_path)
-          logger.directory "#{destination_path(relative_path)}/"
-        end
-
-        def readme(*args)
-          logger.readme args.join(', ')
-        end
-        
-        def migration_template(relative_source, relative_destination, options = {})
-          migration_directory relative_destination
-          logger.migration_template file_name
-        end
-      end
-
-      # Update generator's action manifest.
-      class Update < Create
-        def file(relative_source, relative_destination, options = {})
-          # logger.file relative_destination
-        end
-
-        def template(relative_source, relative_destination, options = {})
-          # logger.template relative_destination
-        end
-
-        def complex_template(relative_source, relative_destination, template_options = {})
-
-           begin
-             dest_file = destination_path(relative_destination)
-             source_to_update = File.readlines(dest_file).join
-           rescue Errno::ENOENT
-             logger.missing relative_destination
-             return
-           end
-
-           logger.refreshing "#{template_options[:insert].gsub(/\.rhtml/,'')} inside #{relative_destination}"
-
-           begin_mark = Regexp.quote(template_part_mark(template_options[:begin_mark], template_options[:mark_id]))
-           end_mark = Regexp.quote(template_part_mark(template_options[:end_mark], template_options[:mark_id]))
-
-           # Refreshing inner part of the template with freshly rendered part.
-           rendered_part = render_template_part(template_options)
-           source_to_update.gsub!(/#{begin_mark}.*?#{end_mark}/m, rendered_part)
-
-           File.open(dest_file, 'w') { |file| file.write(source_to_update) }
-        end
-
-        def directory(relative_path)
-          # logger.directory "#{destination_path(relative_path)}/"
-        end
-      end
-
-    end
-  end
-end