parlement 0.10 → 0.11

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

@@ -1,467 +1,323 @@
-require 'logger'
+# This file contains the Engines module, which holds most of the logic regarding
+# the startup and management of plugins. See Engines for more details.
+#
+# The engines plugin adds to Rails' existing behaviour by producing the +Rails.plugins+
+# PluginList, a list of all loaded plugins in a form which can be easily queried
+# and manipulated. Each instance of Plugin has methods which are used to enhance
+# their behaviour, including mirroring public assets, add controllers, helpers
+# and views and even migration.
+#
+# = init.rb
+# 
+# When the engines plugin loads, it first includes the 
+# Engines::RailsExtensions::RailsInitializer module into Rails::Initializer,
+# overriding a number of the methods used to load plugins.
+#
+# Once this is loaded, Engines.init is called to prepare the application
+# and create the relevant new datastructures (including <tt>Rails.plugins</tt>).
+#
+# Finally, each of the extension modules from Engines::RailsExtensionsis 
+# loaded and included into the relevant Rails classes and modules, enhancing 
+# their behaviour to work better with files from plugins.
 
-# We need to know the version of Rails that we are running before we
-# can override any of the dependency stuff, since Rails' own behaviour
-# has changed over the various releases. We need to explicily make sure
-# that the Rails::VERSION constant is loaded, because such things could
-# not automatically be achieved prior to 1.1, and the location of the
-# file moved in 1.1.1!
-def load_rails_version
-  # At this point, we can't even rely on RAILS_ROOT existing, so we have to figure
-  # the path to RAILS_ROOT/vendor/rails manually
-  rails_base = File.expand_path(
-    File.join(File.dirname(__FILE__), # RAILS_ROOT/vendor/plugins/engines/lib
-    '..', # RAILS_ROOT/vendor/plugins/engines
-    '..', # RAILS_ROOT/vendor/plugins
-    '..', # RAILS_ROOT/vendor
-    'rails', 'railties', 'lib')) # RAILS_ROOT/vendor/rails/railties/lib
-  begin
-    load File.join(rails_base, 'rails', 'version.rb')
-    #puts 'loaded 1.1.1+ from vendor: ' + File.join(rails_base, 'rails', 'version.rb')
-  rescue MissingSourceFile # this means they DON'T have Rails 1.1.1 or later installed in vendor
-    begin
-      load File.join(rails_base, 'rails_version.rb')
-      #puts 'loaded 1.1.0- from vendor: ' + File.join(rails_base, 'rails_version.rb')
-    rescue MissingSourceFile # this means they DON'T have Rails 1.1.0 or previous installed in vendor
-      begin
-        # try and load version information for Rails 1.1.1 or later from the $LOAD_PATH
-        require 'rails/version'
-        #puts 'required 1.1.1+ from load path'
-      rescue LoadError
-        # try and load version information for Rails 1.1.0 or previous from the $LOAD_PATH
-        require 'rails_version'
-        #puts 'required 1.1.0- from load path'
-      end
-    end
-  end
-end
-
-# Actually perform the load
-load_rails_version
-#puts "Detected Rails version: #{Rails::VERSION::STRING}"
+require "engines/plugin_list"
+require "engines/plugin"
 
-require 'engines/ruby_extensions'
-# ... further files are required at the bottom of this file
+# TODO: define a better logger.
+def logger
+  RAILS_DEFAULT_LOGGER
+end
 
-# Holds the Rails Engine loading logic and default constants
+# The Engines module contains most of the methods used during the enhanced
+# startup of Rails plugins.
+#
+# When the Engines plugin loads (its <tt>init.rb</tt> file is evaluated), the
+# Engines.init method is called. This kickstarts the plugins hooks into 
+# the initialization process.
+#
+# == Parameters
+#
+# The Engines module has a number of public configuration parameters:
+#
+# [+public_directory+]  The directory into which plugin assets should be
+#                       mirrored. Defaults to <tt>RAILS_ROOT/public/plugin_assets</tt>.
+# [+schema_info_table+] The table to use when storing plugin migration 
+#                       version information. Defaults to +plugin_schema_info+.
+# [+rails_initializer+] A reference of the Rails initializer instance that
+#                       was used to startup Rails. This is often useful
+#                       when working with the startup process; see
+#                       Engines::RailsExtensions::RailsInitializer for more
+#                       information
+#
+# Additionally, there are a few flags which control the behaviour of
+# some of the features the engines plugin adds to Rails:
+#
+# [+disable_application_view_loading+] A boolean flag determining whether
+#                                      or not views should be loaded from 
+#                                      the main <tt>app/views</tt> directory.
+#                                      Defaults to false; probably only 
+#                                      useful when testing your plugin.
+# [+disable_application_code_loading+] A boolean flag determining whether
+#                                      or not to load controllers/helpers 
+#                                      from the main +app+ directory,
+#                                      if corresponding code exists within 
+#                                      a plugin. Defaults to false; again, 
+#                                      probably only useful when testing 
+#                                      your plugin.
+# [+disable_code_mixing+] A boolean flag indicating whether all plugin
+#                         copies of a particular controller/helper should 
+#                         be loaded and allowed to override each other, 
+#                         or if the first matching file should be loaded 
+#                         instead. Defaults to false.
+#
 module Engines
+  # The name of the public directory to mirror public engine assets into.
+  # Defaults to <tt>RAILS_ROOT/public/plugin_assets</tt>.
+  mattr_accessor :public_directory
+  self.public_directory = File.join(RAILS_ROOT, 'public', 'plugin_assets')
 
-  class << self
-    # Return the version string for this plugin
-    def version
-      "#{Version::Major}.#{Version::Minor}.#{Version::Release}"
-    end
-    
-    # For holding the rails configuration object
-    attr_accessor :rails_config
-    
-    # A flag to stop searching for views in the application
-    attr_accessor :disable_app_views_loading
-    
-    # A flag to stop code being mixed in from the application
-    attr_accessor :disable_app_code_mixing
-  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
+  # The table in which to store plugin schema information. Defaults to
+  # "plugin_schema_info".
+  mattr_accessor :schema_info_table
+  self.schema_info_table = "plugin_schema_info"
 
-  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
+  # A reference to the current Rails::Initializer instance
+  mattr_accessor :rails_initializer
   
-  # An array of active engines. This should be accessed via the Engines.active method.
-  ActiveEngines = []
   
-  # The root directory for engines
-  config :root, File.join(RAILS_ROOT, "vendor", "plugins")
+  #--
+  # These attributes control the behaviour of the engines extensions
+  #++
   
-  # The name of the public folder under which engine files are copied
-  config :public_dir, "engine_files"
+  # Set this to true if views should *only* be loaded from plugins
+  mattr_accessor :disable_application_view_loading
+  self.disable_application_view_loading = false
   
-  class << self
+  # Set this to true if controller/helper code shouldn't be loaded 
+  # from the application
+  mattr_accessor :disable_application_code_loading
+  self.disable_application_code_loading = false
   
-    # Initializes a Rails Engine by loading the engine's init.rb file and
-    # ensuring that any engine controllers are added to the load path.
-    # This will also copy any files in a directory named 'public'
-    # into the public webserver directory. Example usage:
-    #
-    #   Engines.start :login
-    #   Engines.start :login_engine  # equivalent
-    #
-    # A list of engine names can be specified:
-    #
-    #   Engines.start :login, :user, :wiki
-    #
-    # The engines will be loaded in the order given.
-    # If no engine names are given, all engines will be started.
-    #
-    # Options can include:
-    # * :copy_files => true | false
-    #
-    # Note that if a list of engines is given, the options will apply to ALL engines.
-    def start(*args)
-      
-      options = (args.last.is_a? Hash) ? args.pop : {}
-      
-      if args.empty?
-        start_all
-      else
-        args.each do |engine_name|
-          start_engine(engine_name, options)
-        end
-      end
-    end
-
-    # 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
-      plugins = Dir[File.join(config(:root), "*")]
-      Engines.log.debug "considering plugins: #{plugins.inspect}"
-      plugins.each { |plugin|
-        engine_name = File.basename(plugin)
-        if File.exist?(File.join(plugin, "init_engine.rb")) || # if the directory contains init_engine.rb
-          (engine_name =~ /_engine$/) || # or it engines in '_engines'
-          (engine_name =~ /_bundle$/)    # or even ends in '_bundle'
-          
-          start(engine_name) # start the engine...
-        
-        end
-      }
-    end
-
-    # Initialize the routing controller paths. 
-    def initialize_routing
-      # See lib/engines/routing_extensions.rb for more information.
-      ActionController::Routing.controller_paths = Engines.rails_config.controller_paths
-    end
+  # Set this ti true if code should not be mixed (i.e. it will be loaded
+  # from the first valid path on $LOAD_PATH)
+  mattr_accessor :disable_code_mixing
+  self.disable_code_mixing = false
+  
+  
+  private
 
-    def start_engine(engine_name, options={})
-      
-      # 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)}'"
+  # A memo of the bottom of Rails' default load path
+  mattr_accessor :rails_final_load_path
+  # A memo of the bottom of Rails Dependencies load path
+  mattr_accessor :rails_final_dependency_load_path
+  
+  public
+  
+  # Initializes the engines plugin and prepares Rails to start loading
+  # plugins using engines extensions. Within this method:
+  #
+  # 1. Copies of the Rails configuration and initializer are stored;
+  # 2. The Rails.plugins PluginList instance is created;
+  # 3. Any plugins which were loaded before the engines plugin are given 
+  #    the engines treatment via #enhance_loaded_plugins.
+  # 4. The base public directory (into which plugin assets are mirrored)
+  #    is created, if necessary - #initialize_base_public_directory
+  # 5. <tt>config.plugins</tt> is checked to see if a wildcard was present -
+  #    #check_for_star_wildcard
+  #
+  def self.init(rails_configuration, rails_initializer)
+    # First, determine if we're running in legacy mode
+    @legacy_support = self.const_defined?(:LegacySupport) && LegacySupport
 
-      # add the code directories of this engine to the load path
-      add_engine_to_load_path(current_engine)
+    # Store some information about the plugin subsystem
+    Rails.configuration = rails_configuration
 
-      # 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')
+    # We need a hook into this so we can get freaky with the plugin loading itself
+    self.rails_initializer = rails_initializer
+    
+    @load_all_plugins = false    
+    
+    store_load_path_markers
+    
+    Rails.plugins ||= PluginList.new
+    enhance_loaded_plugins # including this one, as it happens.
 
+    initialize_base_public_directory
+    
+    check_for_star_wildcard
+    
+    logger.debug "engines has started."
+  end
 
-      # 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)
-      else      
-        ActionController::Routing.controller_paths << engine_controllers
-        ActionController::Routing.controller_paths << engine_components
-      end
-        
-      # copy the files unless indicated otherwise
-      if options[:copy_files] != false
-        current_engine.mirror_engine_files
-      end
+  # You can enable legacy support by defining the LegacySupport constant
+  # in the Engines module before Rails loads, i.e. at the *top* of environment.rb,
+  # add:
+  # 
+  #   module Engines
+  #     LegacySupport = true
+  #   end
+  #
+  # Legacy Support doesn't actually do anything at the moment. If necessary
+  # we may support older-style 'engines' using this flag.
+  def self.legacy_support?
+    @legacy_support
+  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)
-        # possibly use require_dependency? Hmm.
-      else
-        Engines.log.debug "No init_engines.rb file found for engine '#{current_engine.name}'..."
-      end
-    end
+  # A reference to the currently-loading/loaded plugin. This is present to support
+  # legacy engines; it's preferred to use Rails.plugins[name] in your plugin's
+  # init.rb file in order to get your Plugin instance.
+  def self.current
+    Rails.plugins.last
+  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 = %w(controllers helpers models).collect { |d|
-        File.join(engine.root, 'app', d)
-      }
-      other_dirs = %w(components lib).collect { |d| 
-        File.join(engine.root, d)
-      }
-      load_paths  = (app_dirs + other_dirs).select { |d| File.directory?(d) }
+  # This is set to true if a "*" widlcard is present at the end of
+  # the config.plugins array.  
+  def self.load_all_plugins?
+    @load_all_plugins
+  end
 
-      # 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.
-      
-      old_plugin_paths = []
-      # assumes that all engines are at the bottom of the $LOAD_PATH
-      while (File.expand_path($LOAD_PATH.last).index(File.expand_path(Engines.config(:root))) == 0) do
-        old_plugin_paths.unshift($LOAD_PATH.pop)
+  # Stores a record of the last paths which Rails added to each of the load path
+  # attributes ($LOAD_PATH, Dependencies.load_paths and 
+  # ActionController::Routing.controller_paths) that influence how code is loaded
+  # We need this to ensure that we place our additions to the load path *after*
+  # all Rails' defaults
+  def self.store_load_path_markers
+    self.rails_final_load_path = $LOAD_PATH.last
+    logger.debug "Rails final load path: #{self.rails_final_load_path}"
+    self.rails_final_dependency_load_path = ::Dependencies.load_paths.last
+    logger.debug "Rails final dependency load path: #{self.rails_final_dependency_load_path}"
+  end
+  
+  # Create Plugin instances for plugins loaded before the engines plugin was.
+  # Once a Plugin instance is created, the Plugin#load method is then called
+  # to fully load the plugin. See Plugin#load for more details about how a
+  # plugin is started once engines is involved.
+  def self.enhance_loaded_plugins
+    Engines.rails_initializer.loaded_plugins.each do |name|
+      plugin_path = File.join(self.find_plugin_path(name), name)
+      unless Rails.plugins[name]
+        plugin = Plugin.new(name, plugin_path)
+        logger.debug "enginizing plugin: #{plugin.name} from #{plugin_path}"
+        plugin.load # injects the extra directories into the load path, and mirrors public files
+        Rails.plugins << plugin
       end
-
-
-      # add these LAST on the load path.
-      load_paths.reverse.each { |dir| 
-        if File.directory?(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
-      }
-      
-      # Add the other engines back onto the bottom of the $LOAD_PATH. Put them back on in
-      # the same order.
-      $LOAD_PATH.push(*old_plugin_paths)
-      $LOAD_PATH.uniq!
-    end
-
-    # 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
+    logger.debug "plugins is now: #{Rails.plugins.map { |p| p.name }.join(", ")}"
+  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.
-        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
-Files in this directory are automatically generated from your Rails Engines.
+  # Ensure that the plugin asset subdirectory of RAILS_ROOT/public exists, and
+  # that we've added a little warning message to instruct developers not to mess with
+  # the files inside, since they're automatically generated.
+  def self.initialize_base_public_directory
+    if !File.exist?(self.public_directory)
+      # create the public/engines directory, with a warning message in it.
+      logger.debug "Creating public engine files directory '#{self.public_directory}'"
+      FileUtils.mkdir(self.public_directory)
+      message = %{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.
-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
-    
-    # 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
+should edit the files within the <plugin_name>/assets/ directory itself.}
+      target = File.join(public_directory, "README")
+      File.open(target, 'w') { |f| f.puts(message) } unless File.exist?(target)
     end
-    
-    # Pass a block to perform an operation on each engine. You may pass an argument
-    # to determine the order:
-    # 
-    # * :load_order - in the order they were loaded (i.e. lower precidence engines first).
-    # * :precidence_order - highest precidence order (i.e. last loaded) first
-    def each(ordering=:precidence_order, &block)
-      engines = (ordering == :load_order) ? active.reverse : active
-      engines.each { |e| yield e }
-    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
+  end
   
-  # Creates a new object holding information about an Engine.
-  def initialize(name)
+  # Check for a "*" at the end of the plugins list; if one is found, note that
+  # we should load all other plugins once Rails has finished initializing, and
+  # remove the "*".
+  def self.check_for_star_wildcard
+    if Rails.configuration.plugins && Rails.configuration.plugins.last == "*"
+      Rails.configuration.plugins.pop
+      @load_all_plugins = true
+    end 
+  end
 
-    @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
+  #-
+  # The following code is called once all plugins are loaded, and Rails is almost
+  # finished initialization
+  #+
+
+  # Once the Rails Initializer has finished, the engines plugin takes over
+  # and performs any post-processing tasks it may have, including:
+  #
+  # * Loading any remaining plugins if config.plugins ended with a '*'.
+  # * Updating Rails::Info with version information, if possible.
+  #
+  def self.after_initialize
+    if self.load_all_plugins?
+      logger.debug "loading remaining plugins from #{Rails.configuration.plugin_paths.inspect}"
+      # this will actually try to load ALL plugins again, but any that have already 
+      # been loaded will be ignored.
+      rails_initializer.load_all_plugins
+      update_rails_info_with_loaded_plugins
     end
   end
   
-  # Returns a string describing this engine
-  def info
-    @info || '(none)'
+  # Updates Rails::Info with the list of loaded plugins, and version information for
+  # each plugin. This information is then available via script/about, or through
+  # the builtin rails_info controller.
+  def self.update_rails_info_with_loaded_plugins
+    if defined?(Rails::Info) # since it may not be available by default in some environments... 
+                             # don't do anything if it's not there.
+      Rails::Info.property("Loaded plugins") { Rails.plugins.map { |p| p.name }.join(", ") }
+      Rails.plugins.each do |plugin|
+        Rails::Info.property("#{plugin.name} version") { plugin.version.blank? ? "(unknown)" : plugin.version }
+      end
+    end      
   end
-    
-  # Returns a string representation of this engine
-  def to_s
-    "Engine<'#{@name}' [#{version}]:#{root.gsub(RAILS_ROOT, '')}>"
+  
+  #-
+  # helper methods to find and deal with plugin paths and names
+  #+
+  
+  # Returns the path within +Rails.configuration.plugin_paths+ which includes
+  # a plugin with the given name.
+  def self.find_plugin_path(name)
+    Rails.configuration.plugin_paths.find do |path|
+      File.exist?(File.join(path, name.to_s))
+    end    
   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)
+  # Returns the name for the plugin at the given path.
+  # (Note this method also appears in Rails::Initializer extensions)
+  def self.plugin_name(path)
+    File.basename(path)
   end
   
-  # Replicates the subdirectories under the engine's /public directory into
-  # the corresponding public directory.
-  def mirror_engine_files
+  # A general purpose method to mirror a directory (+source+) into a destination
+  # directory, including all files and subdirectories. Files will not be mirrored
+  # if they are identical already (checked via FileUtils#identical?).
+  def self.mirror_files_from(source, destination)
+    return unless File.directory?(source)
     
-    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  
+    # TODO: use Rake::FileList#pathmap?
     
-      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)
+    source_files = Dir[source + "/**/*"]
+    source_dirs = source_files.select { |d| File.directory?(d) }
+    source_files -= source_dirs  
+    
+    source_dirs.each do |dir|
+      # strip down these paths so we have simple, relative paths we can
+      # add to the destination
+      target_dir = File.join(destination, dir.gsub(source, ''))
+      begin        
+        FileUtils.mkdir_p(target_dir)
+      rescue Exception => e
+        raise "Could not create directory #{target_dir}: \n" + e
       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, 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)
-            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(root, "public"), 
-                             File.join(Engines.public_engine_dir, name))
-          unless File.exist?(target) && FileUtils.identical?(file, 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
-  end  
-end
-
-
-# These files must be required after the Engines module has been defined.
-require 'engines/dependencies_extensions'
-require 'engines/routing_extensions'
-require 'engines/action_view_extensions'
-require 'engines/action_mailer_extensions'
-require 'engines/migration_extensions'
-require 'engines/active_record_extensions'
 
-# only load the testing extensions if we are in the test environment
-require 'engines/testing_extensions' if %w(test).include?(RAILS_ENV)
+    source_files.each do |file|
+      begin
+        target = File.join(destination, file.gsub(source, ''))
+        unless File.exist?(target) && FileUtils.identical?(file, target)
+          FileUtils.cp(file, target)
+        end 
+      rescue Exception => e
+        raise "Could not copy #{file} to #{target}: \n" + e 
+      end
+    end  
+  end
+end