--- /dev/null
+require 'logger'
+
+# 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/ruby_extensions'
+# ... further files are required at the bottom of this file
+
+# Holds the Rails Engine loading logic and default constants
+module Engines
+
+ 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
+
+ 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. This should be accessed via the Engines.active method.
+ 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
+ #
+ # 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
+
+ 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)}'"
+
+ # add the code directories of this engine to the load path
+ add_engine_to_load_path(current_engine)
+
+ # 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')
+
+
+ # 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
+
+ # 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
+
+ # 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) }
+
+ # 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)
+ 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
+
+ # 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.
+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
+ 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
+
+ # 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
+
+ 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, 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)
projects / selectricity-live / blobdiff