parlement 0.3 → 0.4

data/vendor/plugins/engines/lib/engines.rb

@@ -1,37 +1,64 @@
-#--
-# Copyright (c) 2005 James Adam
-#
-# 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.
-#++
+require 'logger'
 
-require 'ruby_extensions'
-require 'dependencies_extensions'
-require 'action_view_extensions'
-require 'action_mailer_extensions'
-require 'testing_extensions'
+ # load this before doing ANYTHING freaky with the reloading.
+begin
+  require 'rails_version' # Rails 1.0, 1.1.0
+rescue LoadError, Gem::Exception
+  require 'rails/version' # renamed as of Rails 1.1.1
+end
 
+require 'engines/ruby_extensions'
+# ... further files are required at the bottom of this file
 
 # Holds the Rails Engine loading logic and default constants
-module ::Engines
+module Engines
+
+  class << self
+    # Return the version string for this plugin
+    def version
+      "#{Version::Major}.#{Version::Minor}.#{Version::Release}"
+    end
+  end
+
+  # The DummyLogger is a class which might pass through to a real Logger
+  # if one is assigned. However, it can gracefully swallow any logging calls
+  # if there is now Logger assigned.
+  class LoggerWrapper
+    def initialize(logger=nil)
+      set_logger(logger)
+    end
+    # Assign the 'real' Logger instance that this dummy instance wraps around.
+    def set_logger(logger)
+      @logger = logger
+    end
+    # log using the appropriate method if we have a logger
+    # if we dont' have a logger, ignore completely.
+    def method_missing(name, *args)
+      if @logger && @logger.respond_to?(name)
+        @logger.send(name, *args)
+      end
+    end
+  end
+
+  LOGGER = Engines::LoggerWrapper.new
+
+  class << self
+    # Create a new Logger instance for Engines, with the given outputter and level    
+    def create_logger(outputter=STDOUT, level=Logger::INFO)
+      LOGGER.set_logger(Logger.new(outputter, level))
+    end
+    # Sets the Logger instance that Engines will use to send logging information to
+    def set_logger(logger)
+      Engines::LOGGER.set_logger(logger) # TODO: no need for Engines:: part
+    end
+    # Retrieves the current Logger instance
+    def log
+      Engines::LOGGER # TODO: no need for Engines:: part
+    end
+    alias :logger :log
+  end
   
-  # An array of active engines (actually paths to active engines)
+  # An array of active engines. This should be accessed via the Engines.active method.
   ActiveEngines = []
   
   # The root directory for engines
@@ -59,8 +86,6 @@ module ::Engines
     #
     # Options can include:
     # * :copy_files => true | false
-    # * :engine_name => the name within the plugins directory this engine resides, if
-    #   different from the first parameter
     #
     # Note that if a list of engines is given, the options will apply to ALL engines.
     def start(*args)
@@ -69,7 +94,6 @@ module ::Engines
       
       if args.empty?
         start_all
-        return
       else
         args.each do |engine_name|
           start_engine(engine_name, options)
@@ -79,72 +103,81 @@ module ::Engines
 
     # Starts all available engines. Plugins are considered engines if they
     # include an init_engine.rb file, or they are named <something>_engine.
-    def start_all()
+    def start_all
       plugins = Dir[File.join(config(:root), "*")]
-      RAILS_DEFAULT_LOGGER.debug "considering plugins: #{plugins.inspect}"
+      Engines.log.debug "considering plugins: #{plugins.inspect}"
       plugins.each { |plugin|
         engine_name = File.basename(plugin)
-        if File.exist?(File.join(plugin, "init_engine.rb")) or
-           (engine_name =~ /_engine$/)
-          # start the engine...
-          start(engine_name)
+        if File.exist?(File.join(plugin, "init_engine.rb")) || # if the directory contains an init_engine.rb file
+          (engine_name =~ /_engine$/) || # or it engines in '_engines'
+          (engine_name =~ /_bundle$/)    # or even ends in '_bundle'
+          
+          start(engine_name) # start the engine...
+        
         end
       }
     end
 
     def start_engine(engine_name, options={})
-
-      current_engine = Engine.new
-      current_engine.name = options[:engine_name] || engine_name
-      current_engine.root = get_engine_dir(engine_name)
       
-      #engine_name = options[:engine_name] || engine
-      #engine_dir = get_engine_dir(engine_name)
+      # Create a new Engine and put this engine at the front of the ActiveEngines list
+      current_engine = Engine.new(engine_name)
+      Engines.active.unshift current_engine
+      Engines.log.info "Starting engine '#{current_engine.name}' from '#{File.expand_path(current_engine.root)}'"
 
-      RAILS_DEFAULT_LOGGER.debug "Trying to start engine '#{current_engine.name}' from '#{File.expand_path(current_engine.root)}'"
+      # add the code directories of this engine to the load path
+      add_engine_to_load_path(current_engine)
 
-      # put this engine at the front of the ActiveEngines list
-      Engines::ActiveEngines.unshift current_engine #engine_dir
+      # add the controller & component path to the Dependency system
+      engine_controllers = File.join(current_engine.root, 'app', 'controllers')
+      engine_components = File.join(current_engine.root, 'components')
 
-      # add the code directories of this engine to the load path
-      add_engine_to_load_path(current_engine) #engine_dir)
+
+      # This mechanism is no longer required in Rails trunk
+      if Rails::VERSION::STRING =~ /^1.0/ && !Engines.config(:edge)
+        Controllers.add_path(engine_controllers) if File.exist?(engine_controllers)
+        Controllers.add_path(engine_components) if File.exist?(engine_components)
+      end
+        
+      # copy the files unless indicated otherwise
+      if options[:copy_files] != false
+        current_engine.mirror_engine_files
+      end
 
       # load the engine's init.rb file
       startup_file = File.join(current_engine.root, "init_engine.rb")
       if File.exist?(startup_file)
         eval(IO.read(startup_file), binding, startup_file)
-        #require startup_file
+        # possibly use require_dependency? Hmm.
       else
-        RAILS_DEFAULT_LOGGER.warn "WARNING: No init_engines.rb file found for engine '#{current_engine.name}'..."
-      end
-
-      # add the controller path to the Dependency system
-      Controllers.add_path(File.join(current_engine.root, 'app', 'controllers'))
-
-      # copy the files unless indicated otherwise
-      if options[:copy_files] != false
-        copy_engine_files(current_engine)
+        Engines.log.debug "No init_engines.rb file found for engine '#{current_engine.name}'..."
       end
     end
 
     # Adds all directories in the /app and /lib directories within the engine
     # to the load path
     def add_engine_to_load_path(engine)
+      
+      # remove the lib directory added by load_plugin, and place it in the corrent
+      # location *after* the application/lib. This can be removed when 
+      # http://dev.rubyonrails.org/ticket/2910 is fixed.
+      app_lib_index = $LOAD_PATH.index(File.join(RAILS_ROOT, "lib"))
+      engine_lib = File.join(engine.root, "lib")
+      if app_lib_index
+        $LOAD_PATH.delete(engine_lib)
+        $LOAD_PATH.insert(app_lib_index+1, engine_lib)
+      end
+      
       # Add ALL paths under the engine root to the load path
-      app_dirs = [engine.root + "/app/controllers", engine.root + "/app/models",
-                  engine.root + "/app/helpers"]
-      lib_dirs = Dir[engine.root + "/lib/**/*"] + [engine.root, "lib"]
-      load_paths = (app_dirs + lib_dirs).select { |d| 
+      app_dirs = Dir[engine.root + "/app/**/*"] # maybe only models?
+      component_dir = Dir[engine.root + "/components"]
+      lib_dirs = Dir[engine.root + "/lib/**/*"]
+      load_paths = (app_dirs + component_dir + lib_dirs).select { |d| 
         File.directory?(d)
       }
 
-      # Remove other engines from the $LOAD_PATH bby matching against the engine.root values
+      # Remove other engines from the $LOAD_PATH by matching against the engine.root values
       # in ActiveEngines. Store the removed engines in the order they came off.
-      #
-      # This is a hack - if Ticket http://dev.rubyonrails.com/ticket/2817 is accepted, then 
-      # a new Engines system can be developed which only modifies load paths in one sweep,
-      # thus avoiding this.
-      #
       
       old_plugin_paths = []
       # assumes that all engines are at the bottom of the $LOAD_PATH
@@ -156,8 +189,9 @@ module ::Engines
       # add these LAST on the load path.
       load_paths.reverse.each { |dir| 
         if File.directory?(dir)
-          RAILS_DEFAULT_LOGGER.debug "adding #{File.expand_path(dir)} to the load path"
-          $LOAD_PATH.push(File.expand_path(dir))  
+          Engines.log.debug "adding #{File.expand_path(dir)} to the load path"
+          #$LOAD_PATH.push(File.expand_path(dir))
+          $LOAD_PATH.push dir
         end
       }
       
@@ -167,18 +201,16 @@ module ::Engines
       $LOAD_PATH.uniq!
     end
 
-    # Replicates the subdirectories under the engine's /public directory into
-    # the corresponding public directory.
-    def copy_engine_files(engine)
-      
-     #engine_dir = get_engine_dir(engine)
-
-      # create the /public/frameworks directory if it doesn't exist
-      public_engine_dir = File.expand_path(File.join(RAILS_ROOT, "public", Engines.config(:public_dir)))
-    
+    # Returns the directory in which all engine public assets are mirrored.
+    def public_engine_dir
+      File.expand_path(File.join(RAILS_ROOT, "public", Engines.config(:public_dir)))
+    end
+  
+    # create the /public/engine_files directory if it doesn't exist
+    def create_base_public_directory
       if !File.exists?(public_engine_dir)
         # create the public/engines directory, with a warning message in it.
-        RAILS_DEFAULT_LOGGER.debug "Creating public engine files directory '#{public_engine_dir}'"
+        Engines.log.debug "Creating public engine files directory '#{public_engine_dir}'"
         FileUtils.mkdir(public_engine_dir)
         File.open(File.join(public_engine_dir, "README"), "w") do |f|
           f.puts <<EOS
@@ -186,107 +218,185 @@ Files in this directory are automatically generated from your Rails Engines.
 They are copied from the 'public' directories of each engine into this directory
 each time Rails starts (server, console... any time 'start_engine' is called).
 Any edits you make will NOT persist across the next server restart; instead you
-should edit the files within the <engine_name>/public directory itself.
+should edit the files within the <engine_name>/public/ directory itself.
 EOS
         end
       end
+    end
+    
+    # Returns the Engine object for the specified engine, e.g.:
+    #    Engines.get(:login)  
+    def get(name)
+      active.find { |e| e.name == name.to_s || e.name == "#{name}_engine" }
+    end
+    alias_method :[], :get
     
-      source = File.join(engine.root, "public") #engine_dir, "public")
-      RAILS_DEFAULT_LOGGER.debug "Attempting to copy public engine files from '#{source}'"
+    # Returns the Engine object for the current engine, i.e. the engine
+    # in which the currently executing code lies.
+    def current
+      current_file = caller[0]
+      active.find do |engine|
+        File.expand_path(current_file).index(File.expand_path(engine.root)) == 0
+      end
+    end
     
+    # Returns an array of active engines
+    def active
+      ActiveEngines
+    end
+  end 
+end
+
+# A simple class for holding information about loaded engines
+class Engine
+  
+  # Returns the base path of this engine
+  attr_accessor :root
+  
+  # Returns the name of this engine
+  attr_reader :name
+  
+  # An attribute for holding the current version of this engine. There are three
+  # ways of providing an engine version. The simplest is using a string:
+  #
+  #   Engines.current.version = "1.0.7"
+  #
+  # Alternatively you can set it to a module which contains Major, Minor and Release
+  # constants:
+  #
+  #   module LoginEngine::Version
+  #     Major = 1; Minor = 0; Release = 6;
+  #   end
+  #   Engines.current.version = LoginEngine::Version
+  #
+  # Finally, you can set it to your own Proc, if you need something really fancy:
+  #
+  #   Engines.current.version = Proc.new { File.open('VERSION', 'r').readlines[0] }
+  # 
+  attr_writer :version
+  
+  # Engine developers can store any information they like in here.
+  attr_writer :info
+  
+  # Creates a new object holding information about an Engine.
+  def initialize(name)
+
+    @root = ''
+    suffixes = ['', '_engine', '_bundle']
+    while !File.exist?(@root) && !suffixes.empty?
+      suffix = suffixes.shift
+      @root = File.join(Engines.config(:root), name.to_s + suffix)
+    end
+
+    if !File.exist?(@root)
+      raise "Cannot find the engine '#{name}' in either /vendor/plugins/#{name}, " +
+        "/vendor/plugins/#{name}_engine or /vendor/plugins/#{name}_bundle."
+    end      
+    
+    @name = File.basename(@root)
+  end
+    
+  # Returns the version string of this engine
+  def version
+    case @version
+    when Module
+      "#{@version::Major}.#{@version::Minor}.#{@version::Release}"
+    when Proc         # not sure about this
+      @version.call
+    when NilClass
+      'unknown'
+    else
+      @version
+    end
+  end
+  
+  # Returns a string describing this engine
+  def info
+    @info || '(none)'
+  end
+    
+  # Returns a string representation of this engine
+  def to_s
+    "Engine<'#{@name}' [#{version}]:#{root.gsub(RAILS_ROOT, '')}>"
+  end
+  
+  # return the path to this Engine's public files (with a leading '/' for use in URIs)
+  def public_dir
+    File.join("/", Engines.config(:public_dir), name)
+  end
+  
+  # Replicates the subdirectories under the engine's /public directory into
+  # the corresponding public directory.
+  def mirror_engine_files
+    
+    begin
+      Engines.create_base_public_directory
+  
+      source = File.join(root, "public")
+      Engines.log.debug "Attempting to copy public engine files from '#{source}'"
+  
       # if there is no public directory, just return after this file
       return if !File.exist?(source)
 
       source_files = Dir[source + "/**/*"]
       source_dirs = source_files.select { |d| File.directory?(d) }
       source_files -= source_dirs  
-      
-      RAILS_DEFAULT_LOGGER.debug "source dirs: #{source_dirs.inspect}"
-
-      # ensure that we are copying to <something>_engine, whatever the user gives us
-      full_engine_name = engine.name
-      full_engine_name += "_engine" if !(full_engine_name =~ /\_engine$/)
+    
+      Engines.log.debug "source dirs: #{source_dirs.inspect}"
 
+      # Create the engine_files/<something>_engine dir if it doesn't exist
+      new_engine_dir = File.join(RAILS_ROOT, "public", public_dir)
+      if !File.exists?(new_engine_dir)
+        # Create <something>_engine dir with a message
+        Engines.log.debug "Creating #{public_dir} public dir"
+        FileUtils.mkdir_p(new_engine_dir)
+      end
 
       # create all the directories, transforming the old path into the new path
       source_dirs.uniq.each { |dir|
         begin        
-
-          # strip out the base path and add the result to the public path
-          relative_dir = dir.gsub(File.join(engine.root, "public"), full_engine_name)
-          target_dir = File.join(public_engine_dir, relative_dir)
+          # strip out the base path and add the result to the public path, i.e. replace 
+          #   ../script/../vendor/plugins/engine_name/public/javascript
+          # with
+          #   engine_name/javascript
+          #
+          relative_dir = dir.gsub(File.join(root, "public"), name)
+          target_dir = File.join(Engines.public_engine_dir, relative_dir)
           unless File.exist?(target_dir)
-            RAILS_DEFAULT_LOGGER.debug "creating directory '#{target_dir}'"
-            FileUtils.mkdir_p(File.join(public_engine_dir, relative_dir))
+            Engines.log.debug "creating directory '#{target_dir}'"
+            FileUtils.mkdir_p(target_dir)
           end
         rescue Exception => e
           raise "Could not create directory #{target_dir}: \n" + e
         end
       }
 
-
-
       # copy all the files, transforming the old path into the new path
       source_files.uniq.each { |file|
         begin
           # change the path from the ENGINE ROOT to the public directory root for this engine
-          target = file.gsub(File.join(engine.root, "public"), 
-                             File.join(public_engine_dir, full_engine_name))
+          target = file.gsub(File.join(root, "public"), 
+                             File.join(Engines.public_engine_dir, name))
           unless File.exist?(target) && FileUtils.identical?(file, target)
-            RAILS_DEFAULT_LOGGER.debug "copying file '#{file}' to '#{target}'"
+            Engines.log.debug "copying file '#{file}' to '#{target}'"
             FileUtils.cp(file, target)
           end 
         rescue Exception => e
           raise "Could not copy #{file} to #{target}: \n" + e 
         end
       }
+    rescue Exception => e
+      Engines.log.warn "WARNING: Couldn't create the engine public file structure for engine '#{name}'; Error follows:"
+      Engines.log.warn e
     end
-
-  
-    #private
-      # Return the directory in which this engine is present
-      def get_engine_dir(engine_name)
-        engine_dir=File.join(Engines.config(:root), engine_name.to_s)
-
-        if !File.exist?(engine_dir)
-          # try adding "_engine" to the end of the path.
-          engine_dir += "_engine"
-          if !File.exist?(engine_dir)
-            raise "Cannot find the engine '#{engine_name}' in either /vendor/plugins/#{engine} or /vendor/plugins/#{engine}_engine..."
-          end
-        end      
-      
-        engine_dir
-      end
-    
-    # Returns the Engine object for the specified engine, e.g.:
-    #    Engines.get(:login)  
-    def get(name)
-      ActiveEngines.find { |e| e.name == name.to_s || e.name == "#{name}_engine" }
-    end
-    
-    # Returns the Engine object for the current engine, i.e. the engine
-    # in which the currently executing code lies.
-    def current()
-      #puts caller.inspect
-      #puts ">>> " + caller[0]
-      current_file = caller[0]
-      ActiveEngines.find do |engine|
-        File.expand_path(current_file).index(File.expand_path(engine.root)) == 0
-      end
-    end    
-  end 
+  end  
 end
 
-# A simple class for holding information about loaded engines
-class Engine
-  
-  # Returns the base path of this engine
-  attr_accessor :root
-  
-  # Returns the name of this engine
-  attr_reader :name
-  
-  def name=(val) @name = val.to_s end
-  def to_s() "Engine<#{@name}>"   end
-end
+
+# These files must be required after the Engines module has been defined.
+require 'engines/dependencies_extensions'
+require 'engines/action_view_extensions'
+require 'engines/action_mailer_extensions'
+require 'engines/testing_extensions'
+require 'engines/migration_extensions'
+require 'engines/active_record_extensions'

data/vendor/plugins/engines/tasks/engines.rake

@@ -0,0 +1,161 @@
+module Engines
+  module RakeTasks
+    def self.all_engines
+      # An engine is informally defined as any subdirectory in vendor/plugins
+      # which ends in '_engine', '_bundle', or contains an 'init_engine.rb' file.
+      engine_base_dirs = ['vendor/plugins']
+      # The engine root may be different; if possible try to include
+      # those directories too
+      if Engines.const_defined?(:CONFIG)
+        engine_base_dirs << Engines::CONFIG[:root]
+      end
+      engine_base_dirs.map! {|d| [d + '/*_engine/*', 
+                                  d + '/*_bundle/*',
+                                  d + '/*/init_engine.rb']}.flatten!
+      engine_dirs = FileList.new(*engine_base_dirs)
+      engine_dirs.map do |engine| 
+        File.basename(File.dirname(engine))
+      end.uniq       
+    end
+  end
+end
+
+
+namespace :engines do
+  desc "Display version information about active engines"
+  task :info => :environment do
+    if ENV["ENGINE"]
+      e = Engines.get(ENV["ENGINE"])
+      header = "Details for engine '#{e.name}':"
+      puts header
+      puts "-" * header.length
+      puts "Version: #{e.version}"
+      puts "Details: #{e.info}"
+    else
+      puts "Engines plugin: #{Engines.version}"
+      Engines.active.each do |e|
+        puts "#{e.name}: #{e.version}"
+      end
+    end
+  end
+end
+
+namespace :db do  
+  namespace :fixtures do
+    namespace :engines do
+      
+      desc "Load plugin/engine fixtures into the current environment's database."
+      task :load => :environment do
+        require 'active_record/fixtures'
+        ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+        plugin = ENV['ENGINE'] || '*'
+        Dir.glob(File.join(RAILS_ROOT, 'vendor', 'plugins', plugin, 'test', 'fixtures', '*.yml')).each do |fixture_file|
+          Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))
+        end
+      end
+      
+    end
+  end
+
+
+  namespace :migrate do
+    
+    desc "Migrate all engines. Target specific version with VERSION=x, specific engine with ENGINE=x"
+    task :engines => :environment do
+      engines_to_migrate = ENV["ENGINE"] ? [Engines.get(ENV["ENGINE"])].compact : Engines.active
+      if engines_to_migrate.empty?
+        puts "Couldn't find an engine called '#{ENV["ENGINE"]}'"
+      else
+        if ENV["VERSION"] && !ENV["ENGINE"]
+          # ignore the VERSION, since it makes no sense in this context; we wouldn't
+          # want to revert ALL engines to the same version because of a misttype
+          puts "Ignoring the given version (#{ENV["VERSION"]})."
+          puts "To control individual engine versions, use the ENGINE=<engine> argument"
+        else
+          engines_to_migrate.each do |engine| 
+            Engines::EngineMigrator.current_engine = engine
+            migration_directory = File.join(engine.root, 'db', 'migrate')
+            if File.exist?(migration_directory)
+              puts "Migrating engine '#{engine.name}'"
+              Engines::EngineMigrator.migrate(migration_directory, ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+            else
+              puts "The db/migrate directory for engine '#{engine.name}' appears to be missing."
+              puts "Should be: #{migration_directory}"
+            end
+          end
+          if ActiveRecord::Base.schema_format == :ruby && !engines_to_migrate.empty?
+            Rake::Task[:db_schema_dump].invoke
+          end
+        end
+      end
+    end
+
+    namespace :engines do
+      Engines::RakeTasks.all_engines.each do |engine_name|
+        desc "Migrate the '#{engine_name}' engine. Target specific version with VERSION=x"
+        task engine_name => :environment do
+          ENV['ENGINE'] = engine_name; Rake::Task['db:migrate:engines'].invoke
+        end
+      end
+    end
+    
+  end
+end
+
+
+# this is just a rip-off from the plugin stuff in railties/lib/tasks/documentation.rake, 
+# because the default plugindoc stuff doesn't support subdirectories like <engine>/app or
+# <engine>/component.
+namespace :doc do
+
+  desc "Generate documation for all installed engines"
+  task :engines => Engines::RakeTasks.all_engines.map {|engine| "doc:engines:#{engine}"}
+
+  namespace :engines do
+    # Define doc tasks for each engine
+    Engines::RakeTasks.all_engines.each do |engine_name|
+      desc "Generation documentation for the '#{engine_name}' engine"
+      task engine_name => :environment do
+        engine_base   = "vendor/plugins/#{engine_name}"
+        options       = []
+        files         = Rake::FileList.new
+        options << "-o doc/plugins/#{engine_name}"
+        options << "--title '#{engine_name.titlecase} Documentation'"
+        options << '--line-numbers --inline-source'
+        options << '--all' # include protected methods
+        options << '-T html'
+
+        files.include("#{engine_base}/lib/**/*.rb")
+        files.include("#{engine_base}/app/**/*.rb") # include the app directory
+        files.include("#{engine_base}/components/**/*.rb") # include the components directory
+        if File.exists?("#{engine_base}/README")
+          files.include("#{engine_base}/README")    
+          options << "--main '#{engine_base}/README'"
+        end
+        files.include("#{engine_base}/CHANGELOG") if File.exists?("#{engine_base}/CHANGELOG")
+
+        options << files.to_s
+
+        sh %(rdoc #{options * ' '})
+      end
+    end
+  end
+end
+
+namespace :test do
+  desc "Run the engine tests in vendor/plugins/**/test (or specify with ENGINE=name)"
+  # NOTE: we're using the Rails 1.0 non-namespaced task here, just to maintain
+  # compatibility with Rails 1.0
+  # TODO: make this work with Engines.config(:root)
+  Rake::TestTask.new(:engines => :prepare_test_database) do |t|
+    t.libs << "test"
+
+    if ENV['ENGINE']
+      t.pattern = "vendor/plugins/#{ENV['ENGINE']}/test/**/*_test.rb"
+    else
+      t.pattern = 'vendor/plugins/**/test/**/*_test.rb'
+    end
+
+    t.verbose = true
+  end  
+end