parlement 0.14 → 0.17

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

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

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

@@ -1,214 +0,0 @@
-# An instance of Plugin is created for each plugin loaded by Rails, and
-# stored in the <tt>Rails.plugins</tt> PluginList 
-# (see Engines::RailsExtensions::RailsInitializer for more details).
-#
-# Once the engines plugin is loaded, other plugins can take advantage of
-# their own instances by accessing either Engines.current, or the preferred mechanism
-#
-#   Rails.plugins[:plugin_name]
-#
-# Useful properties of this object include Plugin#version, which plugin developers
-# can set in their <tt>init.rb</tt> scripts:
-#
-#    Rails.plugins[:my_plugin].version = "1.4.2"
-#
-# Plugin developers can also access the contents of their <tt>about.yml</tt> files
-# via Plugin#about, which returns a Hash if the <tt>about.yml</tt> file exists for
-# this plugin. Note that if <tt>about.yml</tt> contains a "version" key, it will 
-# automatically be loaded into the <tt>version</tt> attribute described above.
-#
-# If this plugin contains paths in directories other than <tt>app/controllers</tt>,
-# <tt>app/helpers</tt>, <tt>app/models</tt> and <tt>components</tt>, authors can
-# declare this by adding extra paths to #code_paths:
-#
-#    Rails.plugin[:my_plugin].code_paths << "app/sweepers" << "vendor/my_lib"
-#
-# Other properties of the Plugin instance can also be set.
-class Plugin
-  
-  # The name of this plugin
-  attr_accessor :name
-
-  # The directory in which this plugin is located
-  attr_accessor :root
-  
-  # The version of this plugin
-  attr_accessor :version
-  
-  # The about.yml information as a Hash, if it exists
-  attr_accessor :about
-  
-  # Plugins can add code paths to this attribute in init.rb if they 
-  # need plugin directories to be added to the load path, i.e.
-  #
-  #   plugin.code_paths << 'app/other_classes'
-  #
-  # Defaults to ["app/controllers", "app/helpers", "app/models", "components"]
-  # (see #default_code_paths). NOTE: if you want to set this, you must
-  # ensure that the engines plugin is loaded before any plugins which
-  # reference this since it's not available before the engines plugin has worked
-  # its magic.
-  attr_accessor :code_paths
-  
-  # Plugins can add paths to this attribute in init.rb if they need
-  # controllers loaded from additional locations. See also #default_controller_paths, and
-  # the caveat surrounding the #code_paths accessor.
-  attr_accessor :controller_paths
-  
-  # The directory in this plugin to mirror into the shared directory
-  # under +public+. See Engines.initialize_base_public_directory
-  # for more information.
-  #
-  # Defaults to "assets" (see default_public_directory).
-  attr_accessor :public_directory
-  
-  protected
-  
-    # The default set of code paths which will be added to $LOAD_PATH
-    # and Dependencies.load_paths
-    def default_code_paths
-      # lib will actually be removed from the load paths when we call
-      # uniq! in #inject_into_load_paths, but it's important to keep it
-      # around (for the documentation tasks, for instance).
-      %w(app/controllers app/helpers app/models components lib)
-    end
-    
-    # The default set of code paths which will be added to the routing system
-    def default_controller_paths
-      %w(app/controllers components)
-    end
-
-    # Attempts to detect the directory to use for public files.
-    # If +assets+ exists in the plugin, this will be used. If +assets+ is missing
-    # but +public+ is found, +public+ will be used.
-    def default_public_directory
-      %w(assets public).select { |dir| File.directory?(File.join(root, dir)) }.first || "assets"
-    end
-
-  public
-  
-  # Creates a new Plugin instance, and loads any other data from <tt>about.yml</tt>
-  def initialize(name, path)
-    @name = name
-    @root = path
-    
-    @code_paths = default_code_paths
-    @controller_paths = default_controller_paths
-    @public_directory = default_public_directory
-    
-    load_about_information
-  end
-  
-  # Load the information from <tt>about.yml</tt>. This Hash is then accessible
-  # from #about.
-  #
-  # If <tt>about.yml</tt> includes a "version", this will be assigned
-  # automatically into #version.
-  def load_about_information
-    about_path = File.join(self.root, 'about.yml')
-    if File.exist?(about_path)
-      @about = YAML.load(File.open(about_path).read)
-      @about.stringify_keys!
-      @version = @about["version"]
-    end
-  end
-  
-  # Load the plugin. Since Rails takes care of evaluating <tt>init.rb</tt> and
-  # adding +lib+ to the <tt>$LOAD_PATH</tt>, we don't need to do that here (see
-  # Engines::RailsExtensions::RailsInitializer.load_plugins_with_engine_additions).
-  # 
-  # Here we add controller/helper code to the appropriate load paths (see 
-  # #inject_into_load_path) and mirror the plugin assets into the shared public
-  # directory (#mirror_public_assets).
-  def load
-    logger.debug "Plugin '#{name}': starting load."
-    
-    inject_into_load_path
-    mirror_public_assets
-    
-    logger.debug "Plugin '#{name}': loaded."
-  end
-  
-  # Adds all directories in the +app+ and +lib+ directories within the engine
-  # to the three relevant load paths mechanism that Rails might use:
-  #
-  # * <tt>$LOAD_PATH</tt>
-  # * <tt>Dependencies.load_paths</tt>
-  # * <tt>ActionController::Routing.controller_paths</tt>
-  #
-  def inject_into_load_path
-
-    load_path_index = $LOAD_PATH.index(Engines.rails_final_load_path)
-    dependency_index = ::Dependencies.load_paths.index(Engines.rails_final_dependency_load_path)
-    
-    # Add relevant paths under the engine root to the load path
-    code_paths.map { |p| File.join(root, p) }.each do |path| 
-      if File.directory?(path)
-        # Add to the load paths
-        $LOAD_PATH.insert(load_path_index + 1, path)
-        # Add to the dependency system, for autoloading.
-        ::Dependencies.load_paths.insert(dependency_index + 1, path)
-      end
-    end
-    
-    # Add controllers to the Routing system specifically. We actually add our paths
-    # to the configuration too, since routing is started AFTER plugins are. Plugins
-    # which are loaded by engines specifically (i.e. because of the '*' in 
-    # +config.plugins+) will need their paths added directly to the routing system, 
-    # since at that point it has already been configured.
-    controller_paths.map { |p| File.join(root, p) }.each do |path|
-      if File.directory?(path)
-        ActionController::Routing.controller_paths << path
-        Rails.configuration.controller_paths << path
-      end
-    end
-
-    $LOAD_PATH.uniq!
-    ::Dependencies.load_paths.uniq!
-    ActionController::Routing.controller_paths.uniq!
-    Rails.configuration.controller_paths.uniq!
-  end
-
-  # Replicates the subdirectories under the plugins's +assets+ (or +public+) directory into
-  # the corresponding public directory. See also Plugin#public_directory for more.
-  def mirror_public_assets
-  
-    begin 
-      source = File.join(root, self.public_directory)
-      # if there is no public directory, just return after this file
-      return if !File.exist?(source)
-
-      logger.debug "Attempting to copy plugin plugin asset files from '#{source}' to '#{Engines.public_directory}'"
-
-      Engines.mirror_files_from(source, File.join(Engines.public_directory, name))
-      
-    rescue Exception => e
-      logger.warn "WARNING: Couldn't create the public file structure for plugin '#{name}'; Error follows:"
-      logger.warn e
-    end
-  end
-
-  # The path to this plugin's public files
-  def public_asset_directory
-    "#{File.basename(Engines.public_directory)}/#{name}"
-  end
-
-  # The directory containing this plugin's migrations (<tt>plugin/db/migrate</tt>)
-  def migration_directory
-    File.join(self.root, 'db', 'migrate')
-  end
-  
-  # Returns the version number of the latest migration for this plugin. Returns
-  # nil if this plugin has no migrations.
-  def latest_migration
-    migrations = Dir[migration_directory+"/*.rb"]
-    return nil if migrations.empty?
-    migrations.map { |p| File.basename(p) }.sort.last.match(/0*(\d+)\_/)[1].to_i
-  end
-  
-  # Migrate this plugin to the given version. See Engines::PluginMigrator for more
-  # information.   
-  def migrate(version = nil)
-    Engines::PluginMigrator.migrate_plugin(self, version)
-  end  
-end

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

@@ -1,31 +0,0 @@
-# The PluginList class is an array, enhanced to allow access to loaded plugins
-# by name, and iteration over loaded plugins in order of priority. This array is used
-# by Engines::RailsExtensions::RailsInitializer to create the Rails.plugins array.
-#
-# Each loaded plugin has a corresponding Plugin instance within this array, and 
-# the order the plugins were loaded is reflected in the entries in this array.
-#
-# For more information, see the Rails module.
-class PluginList < Array
-  # Finds plugins with the set with the given name (accepts Strings or Symbols), or
-  # index. So, Rails.plugins[0] returns the first-loaded Plugin, and Rails.plugins[:engines]
-  # returns the Plugin instance for the engines plugin itself.
-  def [](name_or_index)
-    if name_or_index.is_a?(Fixnum)
-      super
-    else
-      self.find { |plugin| plugin.name.to_s == name_or_index.to_s }
-    end
-  end
-  
-  # Go through each plugin, highest priority first (last loaded first). Effectively,
-  # this is like <tt>Rails.plugins.reverse</tt>, except when given a block, when it behaves
-  # like <tt>Rails.plugins.reverse.each</tt>.
-  def by_precedence(&block)
-    if block_given?
-      reverse.each { |x| yield x }
-    else 
-      reverse
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# The PluginMigrator class contains the logic to run migrations from
-# within plugin directories. The directory in which a plugin's migrations
-# should be is determined by the Plugin#migration_directory method.
-#
-# To migrate a plugin, you can simple call the migrate method (Plugin#migrate)
-# with the version number that plugin should be at. The plugin's migrations
-# will then be used to migrate up (or down) to the given version.
-#
-# For more information, see Engines::RailsExtensions::Migrations
-class Engines::PluginMigrator < ActiveRecord::Migrator
-
-  # We need to be able to set the 'current' engine being migrated.
-  cattr_accessor :current_plugin
-
-  # Runs the migrations from a plugin, up (or down) to the version given
-  def self.migrate_plugin(plugin, version)
-    self.current_plugin = plugin
-    migrate(plugin.migration_directory, version)
-  end
-  
-  # Returns the name of the table used to store schema information about
-  # installed plugins.
-  #
-  # See Engines.schema_info_table for more details.
-  def self.schema_info_table_name
-    ActiveRecord::Base.wrapped_table_name Engines.schema_info_table
-  end
-
-  # Returns the current version of the given plugin
-  def self.current_version(plugin=current_plugin)
-    result = ActiveRecord::Base.connection.select_one(<<-ESQL
-      SELECT version FROM #{schema_info_table_name} 
-      WHERE plugin_name = '#{plugin.name}'
-    ESQL
-    )
-    if result
-      result["version"].to_i
-    else
-      # There probably isn't an entry for this engine in the migration info table.
-      # We need to create that entry, and set the version to 0
-      ActiveRecord::Base.connection.execute(<<-ESQL
-        INSERT INTO #{schema_info_table_name} (version, plugin_name) 
-        VALUES (0,'#{plugin.name}')
-      ESQL
-      )      
-      0
-    end
-  end
-
-  # Sets the version of the plugin in Engines::PluginMigrator.current_plugin to
-  # the given version.
-  def set_schema_version(version)
-    ActiveRecord::Base.connection.update(<<-ESQL
-      UPDATE #{self.class.schema_info_table_name} 
-      SET version = #{down? ? version.to_i - 1 : version.to_i} 
-      WHERE plugin_name = '#{self.current_plugin.name}'
-    ESQL
-    )
-  end
-end

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

@@ -1,6 +0,0 @@
-# This module contains all the extensions that the engines plugin makes to
-# Rails core. Explanations of how each extension works are included as RDoc
-# documentation for each of the modules listed.
-module Engines::RailsExtensions
-  # let's not rely *entirely* on Rails' magic modules. Not just yet.
-end