parlement 0.10 → 0.11

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

@@ -0,0 +1,79 @@
+# 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

@@ -0,0 +1,13 @@
+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,53 +1,40 @@
-#--
-# Copyright (c) 2006 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.
-#
-#
-#
-# = IN OTHER WORDS:
-#
-# You are free to use this software as you please, but if it breaks you'd
-# best not come a'cryin...
-#++
+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
 
-# Load the engines & bundles extensions
-require 'engines'
-require 'bundles'
+# First, require the engines module & core methods
+require "engines"
 
-module ::Engines::Version
-  Major = 1 # change implies compatibility breaking with previous versions
-  Minor = 1 # change implies backwards-compatible change to API
-  Release = 4 # incremented with bug-fixes, updates, etc.
-end
+# Load this before we get actually start engines
+require "engines/rails_extensions/rails_initializer"
+
+# Start the engines mechanism.
+Engines.init(config, self)
 
-#--
-# Create the Engines directory if it isn't present
-#++
-if !File.exist?(Engines.config(:root))
-  Engines.log.debug "Creating engines directory in /vendor"
-  FileUtils.mkdir_p(Engines.config(:root))
+# 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
 
-# Keep a hold of the Rails Configuration object
-Engines.rails_config = config
+# Load the testing extensions, if we are in the test environment.
+require "engines/testing" if RAILS_ENV == "test"
 
-# Initialize the routing (controller_paths)
-Engines.initialize_routing
+# 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

@@ -0,0 +1,32 @@
+$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/{ruby_extensions.rb → deprecated_config_support.rb}

@@ -1,113 +1,135 @@
-#--
-# Add these methods to the top-level module so that they are available in all
-# modules, etc
-#++
-class ::Module
-  # Defines a constant within a module/class ONLY if that constant does
-  # not already exist.
-  #
-  # This can be used to implement defaults in plugins/engines/libraries, e.g.
-  # if a plugin module exists:
-  #   module MyPlugin
-  #     default_constant :MyDefault, "the_default_value"
-  #   end
-  #
-  # then developers can override this default by defining that constant at
-  # some point *before* the module/plugin gets loaded (such as environment.rb)
-  def default_constant(name, value)
-    if !(name.is_a?(String) or name.is_a?(Symbol))
-      raise "Cannot use a #{name.class.name} ['#{name}'] object as a constant name"
-    end
-    if !self.const_defined?(name)
-      self.class_eval("#{name} = #{value.inspect}")
-    end
-  end
-  
-  # A mechanism for defining configuration of Modules. With this
-  # mechanism, default values for configuration can be provided within shareable
-  # code, and the end user can customise the configuration without having to
-  # provide all values.
-  #
-  # Example:
-  #
-  #  module MyModule
-  #    config :param_one, "some value"
-  #    config :param_two, 12345
-  #  end
-  #
-  # Those values can now be accessed by the following method
-  #
-  #   MyModule.config :param_one  
-  #     => "some value"
-  #   MyModule.config :param_two  
-  #     => 12345
-  #
-  # ... or, if you have overrriden the method 'config'
-  #
-  #   MyModule::CONFIG[:param_one]  
-  #     => "some value"
-  #   MyModule::CONFIG[:param_two]  
-  #     => 12345
-  #
-  # Once a value is stored in the configuration, it will not be altered
-  # by subsequent assignments, unless a special flag is given:
-  #
-  #   (later on in your code, most likely in another file)
-  #   module MyModule
-  #     config :param_one, "another value"
-  #     config :param_two, 98765, :force
-  #   end
-  #
-  # The configuration is now:
-  #
-  #   MyModule.config :param_one  
-  #     => "some value" # not changed
-  #   MyModule.config :param_two  
-  #     => 98765
-  #
-  # Configuration values can also be given as a Hash:
-  #
-  #   MyModule.config :param1 => 'value1', :param2 => 'value2'
-  #
-  # Setting of these values can also be forced:
-  #
-  #   MyModule.config :param1 => 'value3', :param2 => 'value4', :force => true
-  #
-  # A value of anything other than false or nil given for the :force key will
-  # result in the new values *always* being set.
-  def config(*args)
-    
-    raise "config expects at least one argument" if args.empty?
-    
-    # extract the arguments
-    if args[0].is_a?(Hash)
-      override = args[0][:force]
-      args[0].delete(:force)
-      args[0].each { |key, value| _handle_config(key, value, override)}
-    else
-      _handle_config(*args)
-    end
-  end
-  
-  private
-    # Actually set the config values
-    def _handle_config(name, value=nil, override=false)
-      if !self.const_defined?("CONFIG")
-        self.class_eval("CONFIG = {}")
-      end
-    
-      if value != nil
-        if override or self::CONFIG[name] == nil
-          self::CONFIG[name] = value 
-        end
-      else
-        # if we pass an array of config keys to config(),
-        # get the array of values back
-        if name.is_a? Array
-          name.map { |c| self::CONFIG[c] }
-        else
-          self::CONFIG[name]
-        end
-      end      
-    end
-end
+# This file contains support for the now-deprecated +config+ method that the engines
+# plugin provided before version 1.2. Instead of using this, plugin authors are
+# now encouraged to create their own Module configuration mechanisms; the 
+# +mattr_accessor+ mechanism provided by ActiveSupport is ideal for this:
+#
+#  module MyPlugin
+#    mattr_accessor :config_value
+#    self.config_value = "default"
+#  end
+#
+# == Using the deprecated config method
+#
+# If you require the config method to be present, change your <tt>environment.rb</tt>
+# file such that the very top of the file looks like this:
+#
+#   require File.join(File.dirname(__FILE__), 'boot')
+#   require File.join(RAILS_ROOT, "vendor", "plugins", "engines",
+#                     "lib", "engines", "deprecated_config_support")
+#
+
+
+# Adds the +config+ and +default_constant+ methods to Module.
+#
+# *IMPORTANT NOTE* - these methods are deprecated. Only use them when you have no
+# other choice. See link:files/lib/engines/deprecated_config_support_rb.html for more
+# information.
+class Module
+  # Defines a constant within a module/class ONLY if that constant does
+  # not already exist.
+  #
+  # This can be used to implement defaults in plugins/engines/libraries, e.g.
+  # if a plugin module exists:
+  #   module MyPlugin
+  #     default_constant :MyDefault, "the_default_value"
+  #   end
+  #
+  # then developers can override this default by defining that constant at
+  # some point *before* the module/plugin gets loaded (such as environment.rb)
+  def default_constant(name, value)
+    if !(name.is_a?(String) or name.is_a?(Symbol))
+      raise "Cannot use a #{name.class.name} ['#{name}'] object as a constant name"
+    end
+    if !self.const_defined?(name)
+      self.class_eval("#{name} = #{value.inspect}")
+    end
+  end
+  
+  # A mechanism for defining configuration of Modules. With this
+  # mechanism, default values for configuration can be provided within shareable
+  # code, and the end user can customise the configuration without having to
+  # provide all values.
+  #
+  # Example:
+  #
+  #  module MyModule
+  #    config :param_one, "some value"
+  #    config :param_two, 12345
+  #  end
+  #
+  # Those values can now be accessed by the following method
+  #
+  #   MyModule.config :param_one  
+  #     => "some value"
+  #   MyModule.config :param_two  
+  #     => 12345
+  #
+  # ... or, if you have overrriden the method 'config'
+  #
+  #   MyModule::CONFIG[:param_one]  
+  #     => "some value"
+  #   MyModule::CONFIG[:param_two]  
+  #     => 12345
+  #
+  # Once a value is stored in the configuration, it will not be altered
+  # by subsequent assignments, unless a special flag is given:
+  #
+  #   (later on in your code, most likely in another file)
+  #   module MyModule
+  #     config :param_one, "another value"
+  #     config :param_two, 98765, :force
+  #   end
+  #
+  # The configuration is now:
+  #
+  #   MyModule.config :param_one  
+  #     => "some value" # not changed
+  #   MyModule.config :param_two  
+  #     => 98765
+  #
+  # Configuration values can also be given as a Hash:
+  #
+  #   MyModule.config :param1 => 'value1', :param2 => 'value2'
+  #
+  # Setting of these values can also be forced:
+  #
+  #   MyModule.config :param1 => 'value3', :param2 => 'value4', :force => true
+  #
+  # A value of anything other than false or nil given for the :force key will
+  # result in the new values *always* being set.
+  def config(*args)
+    
+    raise "config expects at least one argument" if args.empty?
+    
+    # extract the arguments
+    if args[0].is_a?(Hash)
+      override = args[0][:force]
+      args[0].delete(:force)
+      args[0].each { |key, value| _handle_config(key, value, override)}
+    else
+      _handle_config(*args)
+    end
+  end
+  
+  private
+    # Actually set the config values
+    def _handle_config(name, value=nil, override=false)
+      if !self.const_defined?("CONFIG")
+        self.class_eval("CONFIG = {}")
+      end
+    
+      if value != nil
+        if override or self::CONFIG[name] == nil
+          self::CONFIG[name] = value 
+        end
+      else
+        # if we pass an array of config keys to config(),
+        # get the array of values back
+        if name.is_a? Array
+          name.map { |c| self::CONFIG[c] }
+        else
+          self::CONFIG[name]
+        end
+      end      
+    end
+end