parlement 0.1

data/vendor/plugins/engines/init.rb

@@ -0,0 +1,33 @@
+#--
+# 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 'engines'
+
+#--
+# Create the Engines directory if it isn't present
+#++
+if !File.exist?(Engines.config(:root))
+  RAILS_DEFAULT_LOGGER.debug "Creating engines directory in /vendor"
+  FileUtils.mkdir_p(Engines.config(:root))
+end

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

@@ -0,0 +1,160 @@
+#--
+# Copyright (c) 2004 David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Engine Hacks by James Adam, 2005.
+#++
+
+# Overriding ActionMailer to teach it about Engines...
+module ActionMailer
+  class Base
+
+    # Initialize the mailer via the given +method_name+. The body will be
+    # rendered and a new TMail::Mail object created.
+    def create!(method_name, *parameters) #:nodoc:
+      initialize_defaults(method_name)
+      send(method_name, *parameters)
+
+
+      # If an explicit, textual body has not been set, we check assumptions.
+      unless String === @body
+        # First, we look to see if there are any likely templates that match,
+        # which include the content-type in their file name (i.e.,
+        # "the_template_file.text.html.rhtml", etc.). Only do this if parts
+        # have not already been specified manually.
+
+        templates = get_all_templates_for_action(@template)
+        
+        #RAILS_DEFAULT_LOGGER.debug "template: #{@template}; templates: #{templates.inspect}"
+
+        if @parts.empty?
+          
+          # /app/views/<mailer object name> / <action>.something.rhtml
+          
+          #templates = Dir.glob("#{template_path}/#{@template}.*")
+                    
+          # this loop expects an array of paths to actual template files which match
+          # the given action name
+          templates.each do |path|
+            type = (File.basename(path).split(".")[1..-2] || []).join("/")
+            #RAILS_DEFAULT_LOGGER.debug "type: #{type}"
+            next if type.empty?
+            #RAILS_DEFAULT_LOGGER.debug "other bit: #{File.basename(path).split(".")[0..-2].join('.')}"
+            @parts << Part.new(:content_type => type,
+              :disposition => "inline", :charset => charset,
+              :body => render_message(File.basename(path).split(".")[0..-2].join('.'), @body))
+          end
+          unless @parts.empty?
+            @content_type = "multipart/alternative"
+            @charset = nil
+            @parts = sort_parts(@parts, @implicit_parts_order)
+          end
+        end
+
+        # Then, if there were such templates, we check to see if we ought to
+        # also render a "normal" template (without the content type). If a
+        # normal template exists (or if there were no implicit parts) we render
+        # it.
+        template_exists = @parts.empty?
+        #template_exists ||= Dir.glob("#{template_path}/#{@template}.*").any? { |i| i.split(".").length == 2 }
+        template_exists ||= templates.any? { |i| File.basename(i).split(".").length == 2 }
+        #RAILS_DEFAULT_LOGGER.debug "template_exists? #{template_exists}"
+        @body = render_message(@template, @body) if template_exists
+
+        # Finally, if there are other message parts and a textual body exists,
+        # we shift it onto the front of the parts and set the body to nil (so
+        # that create_mail doesn't try to render it in addition to the parts).
+        if !@parts.empty? && String === @body
+          @parts.unshift Part.new(:charset => charset, :body => @body)
+          @body = nil
+        end
+      end
+
+      # If this is a multipart e-mail add the mime_version if it is not
+      # already set.
+      @mime_version ||= "1.0" if !@parts.empty?
+
+      # build the mail object itself
+      @mail = create_mail
+    end
+
+    private
+
+
+      # JGA - Modified to pass the method name to initialize_template_class
+      def render(opts)
+        body = opts.delete(:body)
+        initialize_template_class(body, opts[:file]).render(opts)
+      end
+
+      
+      # Return all ActionView template paths from the app and all Engines
+      def template_paths
+        paths = [template_path]
+        Engines::ActiveEngines.each { |engine|
+          # add a path for every engine if one exists.
+          engine_template_path = File.join(engine.root, "app", "views", mailer_name)
+          paths << engine_template_path if File.exists?(engine_template_path)
+        }
+        paths
+      end
+
+      # Returns a list of all template paths in the app and Engines
+      # which contain templates that might be used for the given action
+      def get_all_templates_for_action(action)
+        # can we trust uniq! to do this? i'm not sure...
+        templates = []
+        seen_names = []
+        template_paths.each { |path|
+          all_templates_for_path = Dir.glob(File.join(path, "#{action}.*"))
+          all_templates_for_path.each { |template|
+            name = File.basename(template)
+            if !seen_names.include?(name)
+              seen_names << name
+              templates << template
+            end
+          }
+        }
+        templates
+      end
+
+      # Returns the first path to the given template in our
+      # app/Engine 'chain'.
+      def find_template_root_for(template)
+        all_paths = get_all_templates_for_action(template)
+        if all_paths.empty?
+          return template_path
+        else
+          return File.dirname(all_paths[0])
+        end
+      end
+
+      # JGA - changed here to include the method name that we
+      # are interested in, so that we can re-locate the proper
+      # template root
+      def initialize_template_class(assigns, method_name)
+        engine_template = find_template_root_for(method_name)
+        ActionView::Base.new(engine_template, assigns, self)
+      end
+
+
+  end
+end

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

@@ -0,0 +1,130 @@
+#--
+# Copyright (c) 2004 David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Engine Hacks by James Adam, 2005.
+#++
+
+require 'fileutils'
+
+module ::ActionView
+  class Base
+    private
+      def full_template_path(template_path, extension)
+
+        # If the template exists in the normal application directory,
+        # return that path
+        default_template = "#{@base_path}/#{template_path}.#{extension}"
+        return default_template if File.exist?(default_template)
+
+        # Otherwise, check in the engines to see if the template can be found there.
+        # Load this in order so that more recently started Engines will take priority.
+        Engines::ActiveEngines.each do |engine|
+          site_specific_path = File.join(engine.root, 'app', 'views',  template_path.to_s + '.' + extension.to_s)
+          return site_specific_path if File.exist?(site_specific_path)
+        end
+
+        # If it cannot be found anywhere, return the default path, where the
+        # user *should* have put it.  
+        return "#{@base_path}/#{template_path}.#{extension}" 
+      end
+  end
+
+
+  # add methods to handle including javascripts and stylesheets
+  module Helpers
+    module AssetTagHelper
+      # Returns a stylesheet link tag to the named stylesheet(s) for the given
+      # engine. A stylesheet with the same name as the engine is included automatically.
+      # If other names are supplied, those stylesheets from within the same engine
+      # will be linked too.
+      #
+      #   engine_stylesheet "my_engine" =>
+      #   <link href="/engine_files/my_engine/stylesheets/my_engine.css" media="screen" rel="Stylesheet" type="text/css" />
+      #
+      #   engine_stylesheet "my_engine", "another_file", "one_more" =>
+      #   <link href="/engine_files/my_engine/stylesheets/my_engine.css" media="screen" rel="Stylesheet" type="text/css" />
+      #   <link href="/engine_files/my_engine/stylesheets/another_file.css" media="screen" rel="Stylesheet" type="text/css" />
+      #   <link href="/engine_files/my_engine/stylesheets/one_more.css" media="screen" rel="Stylesheet" type="text/css" />
+      #
+      # Any options supplied as a Hash as the last argument will be processed as in
+      # stylesheet_link_tag.
+      #
+      def engine_stylesheet(engine_name, *sources)
+        stylesheet_link_tag(*convert_public_sources(engine_name, :stylesheet, sources))
+      end
+
+      # Returns a javascript link tag to the named stylesheet(s) for the given
+      # engine. A javascript file with the same name as the engine is included automatically.
+      # If other names are supplied, those javascript from within the same engine
+      # will be linked too.
+      #
+      #   engine_javascript "my_engine" =>
+      #   <script type="text/javascript" src="/engine_files/my_engine/javascripts/my_engine.js"></script>
+      #
+      #   engine_javascript "my_engine", "another_file", "one_more" =>
+      #   <script type="text/javascript" src="/engine_files/my_engine/javascripts/my_engine.js"></script>
+      #   <script type="text/javascript" src="/engine_files/my_engine/javascripts/another_file.js"></script>
+      #   <script type="text/javascript" src="/engine_files/my_engine/javascripts/one_more.js"></script>
+      #
+      # Any options supplied as a Hash as the last argument will be processed as in
+      # javascript_include_tag.
+      #
+      def engine_javascript(engine_name, *sources)
+        javascript_include_tag(*convert_public_sources(engine_name, :javascript, sources))       
+      end
+      
+      private
+        # convert the engine public file sources into actual public paths
+        # type:
+        #   :stylesheet
+        #   :javascript
+        # if engine_name does not end in engine, "_engine" is appended automatically. 
+        def convert_public_sources(engine_name, type, sources)
+          options = sources.last.is_a?(Hash) ? sources.pop.stringify_keys : { }
+          new_sources = []
+        
+          full_engine_name = engine_name
+          full_engine_name += "_engine" if !(engine_name =~ /\_engine$/)
+
+          case type
+            when :javascript
+              type_dir = "javascripts"
+              ext = "js"
+            when :stylesheet
+              type_dir = "stylesheets"
+              ext = "css"
+          end
+          
+          default = "/#{Engines.config(:public_dir)}/#{full_engine_name}/#{type_dir}/#{engine_name}"
+          if defined?(RAILS_ROOT) && File.exists?(File.join(RAILS_ROOT, "public", "#{default}.#{ext}"))
+            new_sources << default
+          end
+        
+          sources.each { |name| 
+            new_sources << "/#{Engines.config(:public_dir)}/#{full_engine_name}/#{type_dir}/#{name}"
+          }
+
+          new_sources << options         
+        end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+#--
+# Copyright (c) 2004 David Heinemeier Hansson
+
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Engine Hacks by James Adam, 2005.
+#++
+
+module ::Dependencies
+  def require_or_load(file_name)
+    # try and load the framework code first
+    # can't use model, as there's nothing in the name to indicate that the file is a 'model' file
+    # rather than a library or anything else.
+    ['controller', 'helper'].each do |type| 
+      if file_name.include?('_' + type)
+        Engines::ActiveEngines.reverse.each do |engine|
+          engine_file_name = File.join(engine.root, 'app', "#{type}s",  File.basename(file_name))
+          engine_file_name += '.rb' unless engine_file_name[-3..-1] == '.rb'
+          if File.exist? engine_file_name
+            load? ? load(engine_file_name) : require(engine_file_name)
+          end
+        end
+      end
+    end
+
+    # finally, load any application-specific controller classes.
+    file_name = "#{file_name}.rb" unless ! load? || file_name [-3..-1] == '.rb'
+    load? ? load(file_name) : require(file_name)
+  end
+
+  class RootLoadingModule < LoadingModule
+    # hack to allow adding to the load paths within the Rails Dependencies mechanism.
+    # this allows Engine classes to be unloaded and loaded along with standard
+    # Rails application classes.
+    def add_path(path)
+      @load_paths << (path.kind_of?(ConstantLoadPath) ? path : ConstantLoadPath.new(path))
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+#--
+# 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 'ruby_extensions'
+require 'dependencies_extensions'
+require 'action_view_extensions'
+require 'action_mailer_extensions'
+require 'testing_extensions'
+
+
+# Holds the Rails Engine loading logic and default constants
+module ::Engines
+  
+  # An array of active engines (actually paths to active engines)
+  ActiveEngines = []
+  
+  # The root directory for engines
+  config :root, File.join(RAILS_ROOT, "vendor", "plugins")
+  
+  # The name of the public folder under which engine files are copied
+  config :public_dir, "engine_files"
+  
+  class << self
+  
+    # 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
+    # * :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)
+      
+      options = (args.last.is_a? Hash) ? args.pop : {}
+      
+      if args.empty?
+        start_all
+        return
+      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), "*")]
+      RAILS_DEFAULT_LOGGER.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)
+        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)
+
+      RAILS_DEFAULT_LOGGER.debug "Trying to start engine '#{current_engine.name}' from '#{File.expand_path(current_engine.root)}'"
+
+      # put this engine at the front of the ActiveEngines list
+      Engines::ActiveEngines.unshift current_engine #engine_dir
+
+      # add the code directories of this engine to the load path
+      add_engine_to_load_path(current_engine) #engine_dir)
+
+      # 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
+      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)
+      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)
+      # 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| 
+        File.directory?(d)
+      }
+
+      # Remove other engines from the $LOAD_PATH bby 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
+      while (File.expand_path($LOAD_PATH.last).index(File.expand_path(Engines.config(:root))) == 0) do
+        old_plugin_paths.unshift($LOAD_PATH.pop)
+      end
+
+
+      # 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))  
+        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
+
+    # 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)))
+    
+      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}'"
+        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.
+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
+    
+      source = File.join(engine.root, "public") #engine_dir, "public")
+      RAILS_DEFAULT_LOGGER.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$/)
+
+
+      # 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)
+          unless File.exist?(target_dir)
+            RAILS_DEFAULT_LOGGER.debug "creating directory '#{target_dir}'"
+            FileUtils.mkdir_p(File.join(public_engine_dir, relative_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))
+          unless File.exist?(target) && FileUtils.identical?(file, target)
+            RAILS_DEFAULT_LOGGER.debug "copying file '#{file}' to '#{target}'"
+            FileUtils.cp(file, target)
+          end 
+        rescue Exception => e
+          raise "Could not copy #{file} to #{target}: \n" + e 
+        end
+      }
+    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
+
+# 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