parlement 0.14 → 0.17

data/vendor/plugins/engines/about.yml

@@ -1,7 +0,0 @@
-author: James Adam
-email: james.adam@gmail.com
-homepage: http://www.rails-engines.org
-summary: Enhances the plugin mechanism to perform more flexible sharing
-description: The Rails Engines plugin allows the sharing of almost any type of code or asset that you could use in a Rails application, including controllers, models, stylesheets, and views.
-license: MIT
-version: 1.2.0

data/vendor/plugins/engines/generators/plugin_migration/USAGE

@@ -1,45 +0,0 @@
-Description:
-  The plugin migration generator assists in working with schema additions 
-  required by plugins. Instead of running migrations from plugins directly,
-  the generator creates a regular Rails migration which will be responsible
-  for migrating the plugins from their current version to the latest version
-  installed.
-  
-  This is important because the set of application migrations remains an
-  accurate record of the state of the database, even as plugins are installed
-  and removed during the development process.
-
-Example:
-  ./script/generate plugin_migration [<plugin_name> <another_plugin_name> ...]
-
-  This will generate:
-
-    RAILS_ROOT
-      |- db
-          |-migrate
-              |- xxx_plugin_migrations.rb
-
-  which contains the migrations for the given plugin(s).
-  
-  
-Advanced Usage:
-
-There may be situations where you need *complete* control over the migrations
-of plugins in your application, migrating a certainly plugin down to X, and
-another plugin up to Y, where neither X or Y are the latest migrations for those
-plugins.
-
-For those unfortunate few, I have two pieces of advice:
-
- 1. Why? This is a code smell [http://c2.com/xp/CodeSmell.html].
- 
- 2. Well, OK. Don't panic. You can completely control plugin migrations by
-    creating your own migrations. To manually migrate a plugin to a specific
-    version, simply use
-    
-      Rails.plugins[:your_plugin_name].migrate(version)
-      
-    where version is the integer of the migration this plugin should end
-    up at.
-    
-With great power comes great responsibility. Use this wisely.

data/vendor/plugins/engines/generators/plugin_migration/plugin_migration_generator.rb

@@ -1,79 +0,0 @@
-# Generates a migration which migrates all plugins to their latest versions
-# within the database.
-class PluginMigrationGenerator < Rails::Generator::Base
-  
-  def initialize(runtime_args, runtime_options={})
-    super
-    @options = {:assigns => {}}
-    
-    ensure_plugin_schema_table_exists
-    get_plugins_to_migrate(runtime_args)
-    
-    if @plugins_to_migrate.empty?
-      puts "All plugins are migrated to their latest versions"
-      exit(0)
-    end
-
-    @options[:migration_file_name] = build_migration_name
-    @options[:assigns][:class_name] = build_migration_name.classify
-  end
-  
-  def manifest
-    record do |m|
-      m.migration_template 'plugin_migration.erb', 'db/migrate', @options
-    end
-  end
-  
-  protected
-  
-    # Create the plugin schema table if it doesn't already exist. See
-    # Engines::RailsExtensions::Migrations#initialize_schema_information_with_engine_additions
-    def ensure_plugin_schema_table_exists
-      ActiveRecord::Base.connection.initialize_schema_information
-    end
-
-    # Determine all the plugins which have migrations that aren't present
-    # according to the plugin schema information from the database.
-    def get_plugins_to_migrate(plugin_names)
-      
-      # First, grab all the plugins which exist and have migrations
-      @plugins_to_migrate = if plugin_names.empty?
-        Rails.plugins
-      else
-        plugin_names.map do |name| 
-          Rails.plugins[name] ? Rails.plugins[name] : raise("Cannot find the plugin '#{name}'")
-        end
-      end
-      
-      @plugins_to_migrate.reject! { |p| p.latest_migration.nil? }
-      
-      # Then find the current versions from the database    
-      @current_versions = {}
-      @plugins_to_migrate.each do |plugin|
-        @current_versions[plugin.name] = Engines::PluginMigrator.current_version(plugin)
-      end
-
-      # Then find the latest versions from their migration directories
-      @new_versions = {}      
-      @plugins_to_migrate.each do |plugin|
-        @new_versions[plugin.name] = plugin.latest_migration
-      end
-      
-      # Remove any plugins that don't need migration
-      @plugins_to_migrate.map { |p| p.name }.each do |name|
-        @plugins_to_migrate.delete(Rails.plugins[name]) if @current_versions[name] == @new_versions[name]
-      end
-      
-      @options[:assigns][:plugins] = @plugins_to_migrate
-      @options[:assigns][:new_versions] = @new_versions
-      @options[:assigns][:current_versions] = @current_versions
-    end
-
-    # Construct a unique migration name based on the plugins involved and the
-    # versions they should reach after this migration is run.
-    def build_migration_name
-      @plugins_to_migrate.map do |plugin| 
-        "#{plugin.name}_to_version_#{@new_versions[plugin.name]}" 
-      end.join("_and_")
-    end  
-end

data/vendor/plugins/engines/generators/plugin_migration/templates/plugin_migration.erb

@@ -1,13 +0,0 @@
-class <%= class_name %> < ActiveRecord::Migration
-  def self.up
-  <%- plugins.each do |plugin| -%>
-    Rails.plugins["<%= plugin.name %>"].migrate(<%= new_versions[plugin.name] %>)
-  <%- end -%>
-  end
-
-  def self.down
-  <%- plugins.each do |plugin| -%>
-    Rails.plugins["<%= plugin.name %>"].migrate(<%= current_versions[plugin.name] %>)
-  <%- end -%>
-  end
-end

data/vendor/plugins/engines/init.rb

@@ -1,40 +0,0 @@
-begin
-  silence_warnings { require 'rails/version' } # it may already be loaded
-  unless Rails::VERSION::MAJOR >= 1 && Rails::VERSION::MINOR >= 2
-    raise "This version of the engines plugin requires Rails 1.2 or later!"
-  end
-end
-
-# First, require the engines module & core methods
-require "engines"
-
-# Load this before we get actually start engines
-require "engines/rails_extensions/rails_initializer"
-
-# Start the engines mechanism.
-Engines.init(config, self)
-
-# Now that we've defined the engines module, load up any extensions
-[:rails,
- :rails_initializer,
- :dependencies,
- :active_record,
- :migrations,
- :templates,
- :public_asset_helpers,
- :routing
-].each do |f|
-  require "engines/rails_extensions/#{f}"
-end
-
-# Load the testing extensions, if we are in the test environment.
-require "engines/testing" if RAILS_ENV == "test"
-
-# Load the Rails::Info module so that plugins can insert information into it.
-begin
-  require 'rails/info'
-rescue Exception
-  # If this file can't be loaded, it's probably because we're running in an
-  # environment where Rails' builtins aren't yet in the load path.
-  # For the moment, just ignore this. See Ticket #261
-end

data/vendor/plugins/engines/install.rb

@@ -1,32 +0,0 @@
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "..", "rails", "railties", "lib")
-silence_warnings { require 'rails/version' } # it may already be loaded.
-
-unless Rails::VERSION::MAJOR >= 1 && Rails::VERSION::MINOR >= 2
-  puts <<-end_of_warning
-
-         !!!=== IMPORTANT NOTE ===!!!
-
-Support for Rails < 1.2 has been dropped; if you are using 
-Rails =< 1.1.6, please use Engines 1.1.6, available from: 
-
-  >>  http://svn.rails-engines.org/engines/tags/rel_1.1.6
-
-For more details about changes in Engines 1.2, please see 
-the changelog or the website: 
-
-  >>  http://www.rails-engines.org
-
-end_of_warning
-else
-  puts <<-end_of_message
-  
-The engines plugin is now installed. Feels good, right? Yeah. 
-You knew it would.
-
-Once the warm, fuzzy glow has subsided, be sure to read the contents 
-of the README and UPGRADING files if you're migrating this application 
-from Rails 1.1.x to 1.2.x.
-
-Have a great day!
-end_of_message
-end

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

@@ -1,323 +0,0 @@
-# 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.
-
-require "engines/plugin_list"
-require "engines/plugin"
-
-# TODO: define a better logger.
-def logger
-  RAILS_DEFAULT_LOGGER
-end
-
-# 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')
-
-  # 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"
-
-  # A reference to the current Rails::Initializer instance
-  mattr_accessor :rails_initializer
-  
-  
-  #--
-  # These attributes control the behaviour of the engines extensions
-  #++
-  
-  # Set this to true if views should *only* be loaded from plugins
-  mattr_accessor :disable_application_view_loading
-  self.disable_application_view_loading = false
-  
-  # 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
-  
-  # 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
-
-  # 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
-
-    # Store some information about the plugin subsystem
-    Rails.configuration = rails_configuration
-
-    # 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
-
-  # 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
-
-  # 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
-
-  # 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
-
-  # 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
-    end
-    logger.debug "plugins is now: #{Rails.plugins.map { |p| p.name }.join(", ")}"
-  end  
-  
-  # 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 <plugin_name>/assets/ directory itself.}
-      target = File.join(public_directory, "README")
-      File.open(target, 'w') { |f| f.puts(message) } unless File.exist?(target)
-    end
-  end
-  
-  # 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
-
-
-  #-
-  # 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
-  
-  # 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
-  
-  #-
-  # 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
-  
-  # 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
-  
-  # 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)
-    
-    # TODO: use Rake::FileList#pathmap?
-    
-    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
-    end
-
-    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