loaded_plugins 0.1.2

data/CHANGELOG

@@ -0,0 +1,62 @@
+*SVN*
+
+*0.1.2* (August 25th, 2007)
+
+* Refactor unit tests
+
+* Convert dos newlines to unix newlines
+
+*0.1.1* (August 7th, 2007)
+
+* Update documentation
+
+* Simplify tracking of plugins that are missed before loaded_plugins is loaded
+
+* Move '*' support in config.plugins to a separate plugin (see partial_plugin_list plugin).
+
+* Move loaded_plugins/loaded_plugins.rb code to where it belongs in loaded_plugins/extensions/initializer.rb
+
+* Add support for '*' in configuration.plugins like so (based on James Adam's Engines 1.2):
+  
+  Rails::Initializer.run do |config|
+    config.plugins = [
+      'plugins_plus',
+      '*'
+    ]
+  end
+
+* If a plugin path cannot be found, continue loading it as normal rather than failing.  This:
+  (1) Produces a descriptive error if the plugin doesn't really exist
+  (2) Allows you to call load_plugin from within your plugin's init.rb (e.g. if you have other plugins via svn:externals within your plugin)
+
+*0.1.0* (March 31st, 2007)
+
+* Add a more diverse set of Plugin callbacks (before_load, after_load, and after_initialize)
+
+* Add support for getting the proper name of plugin gem formats (i.e. plugin_xyz-1.2.0)
+
+* Respect manual specification of plugins in configuration.plugins instead of assuming that all plugins will be loaded
+
+* Refactor laded_plugins.rb into files for each individual class being extended. #12 [Brian Takita]
+
+* Adopt James Adam's Engines 1.2 style of tracking plugins
+
+* Added empty files so that test directories get added to the gem
+
+*0.0.4 (February 15th, 2007)
+
+* Don't add plugins that weren't specified in the configuration
+
+*0.0.3* (February 3rd, 2007)
+
+* Fix inserting already-loaded plugins in the wrong order when loaded_plugins has been loaded as a gem midway through initialization
+
+* Moved tasks into lib files so that they could be more easily tested
+
+*0.0.2* (February 1st, 2007)
+
+* When using dependencies, dependent plugins now appear +before+ the plugin that required them
+
+*0.0.1* (November 2nd, 2006)
+
+* Initial release

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2007 James Adam, 2006-2007 Aaron Pfeifer, Neil Abraham
+
+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.

data/README

@@ -0,0 +1,66 @@
+= loaded_plugins
+
+loaded_plugins adds +Rails.plugins+, a list all of the plugins that Rails has
+loaded.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/loaded_plugins
+
+Wiki
+
+* http://wiki.pluginaweek.org/Loaded_plugins
+
+Announcement
+
+* http://www.pluginaweek.org/2006/11/02/2-loaded_plugins-a-monkey-plugin
+
+Source
+
+* http://svn.pluginaweek.org/trunk/plugins/rails/loaded_plugins
+
+Development
+
+* http://dev.pluginaweek.org/browser/trunk/plugins/rails/loaded_plugins
+
+== Description
+
+During initialization, +Rails.plugins+ will keep track of a list of all of the
+plugins that have been loaded so far.  Once initialization is complete,
++Rails.plugins+ will contain all of the plugins loaded in the application.
+
+The order of the plugins will be based on the order in which the plugins were
+loaded during initialization.
+
+== Usage
+
+If you need access to Rails.plugins during initialization of your application,
+you must use one of two things:
+
+1. Use config.plugins to specify the order in which plugins are
+loaded, for example:
+
+  Rails::Initializer.run do |config|
+    ...
+    config.plugins = [
+      'loaded_plugins',
+      ...
+    ]
+  end
+
+2. Require the plugin with the plugin_dependencies plugin installed.
+
+If using +require+ without plugin_dependencies installed, loaded_plugins will
+not track all of the plugins that were loaded prior to it being loaded until *after*
+initialization is complete.
+
+Also, note that the plugins are listed in the order that they are *completely*
+loaded.  That is, only after the entire initialization of a plugin is complete
+will it get added to Rails.plugins.
+  
+== References
+
+This plugin has been heavily influenced by the work James Adam has done in
+Engines 1.2 (http://www.rails-engines.org/).

data/Rakefile

@@ -0,0 +1,79 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+PKG_NAME           = 'loaded_plugins'
+PKG_VERSION        = '0.1.2'
+PKG_FILE_NAME      = "#{PKG_NAME}-#{PKG_VERSION}"
+RUBY_FORGE_PROJECT = 'pluginaweek'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the loaded_plugins plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the loaded_plugins plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LoadedPlugins'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+spec = Gem::Specification.new do |s|
+  s.name            = PKG_NAME
+  s.version         = PKG_VERSION
+  s.platform        = Gem::Platform::RUBY
+  s.summary         = 'Adds Rails.plugins, a list all of the plugins that Rails has loaded'
+  
+  s.files           = FileList['{lib,test}/**/*'].to_a + %w(CHANGELOG init.rb MIT-LICENSE Rakefile README)
+  s.require_path    = 'lib'
+  s.autorequire     = 'loaded_plugins'
+  s.has_rdoc        = true
+  s.test_files      = Dir['test/**/*_test.rb']
+  
+  s.author          = 'Aaron Pfeifer, Neil Abraham'
+  s.email           = 'info@pluginaweek.org'
+  s.homepage        = 'http://www.pluginaweek.org'
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('pluginaweek@pluginaweek.org', '/home/pluginaweek/gems.pluginaweek.org/gems', 'pkg', "#{PKG_FILE_NAME}.gem").upload
+end
+
+desc 'Publish the API documentation'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('pluginaweek@pluginaweek.org', "/home/pluginaweek/api.pluginaweek.org/#{PKG_NAME}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new
+  ruby_forge.login
+  
+  %w( gem tgz zip ).each do |ext|
+    file = "pkg/#{PKG_FILE_NAME}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(RUBY_FORGE_PROJECT, PKG_NAME, PKG_VERSION, file)
+  end
+end

data/init.rb

@@ -0,0 +1,3 @@
+require 'loaded_plugins'
+
+extend PluginAWeek::LoadedPlugins::Extensions::Initializer

data/lib/loaded_plugins.rb

@@ -0,0 +1,4 @@
+require 'loaded_plugins/plugin'
+require 'loaded_plugins/plugin_list'
+require 'loaded_plugins/extensions/rails'
+require 'loaded_plugins/extensions/initializer'

data/lib/loaded_plugins/extensions/initializer.rb

@@ -0,0 +1,81 @@
+module PluginAWeek #:nodoc:
+  module LoadedPlugins
+    module Extensions #:nodoc:
+      # Keeps track of all the plugins that Rails loaded during initialization
+      module Initializer
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method_chain :load_plugin, :loaded_plugins
+            alias_method_chain :after_initialize, :loaded_plugins
+          end
+        end
+        
+        def self.extended(initializer) #:nodoc:
+          # Get all of the paths we missed before this plugin was loaded.  This
+          # is only necessary for plugins that need +Rails.plugins+ during
+          # initialization.
+          initializer.add_loaded_plugins
+        end
+        
+        # Loads the plugin from the specified directory, tracking all successfully
+        # loaded plugins in +Rails.plugins+
+        def load_plugin_with_loaded_plugins(directory)
+          plugin = Plugin.new(directory)
+          return false if loaded_plugins.include?(plugin.name)
+          
+          # Be careful to place the plugin in the correct order in case a plugin
+          # has required another plugin
+          if @loaded_plugin_index
+            Rails.plugins.insert(@loaded_plugin_index, plugin)
+          else
+            Rails.plugins << plugin
+            @loaded_plugin_index = Rails.plugins.size - 1
+          end
+          
+          # Plugin is about to be loaded
+          plugin.before_load
+          
+          load_plugin_without_loaded_plugins(directory)
+          
+          # Plugin has been loaded
+          plugin.after_load
+          
+          # We no longer need to track the current index in LOADED_PLUGINS if
+          # we're the last one
+          @loaded_plugin_index = nil if Rails.plugins.last == plugin
+          
+          true
+        end
+        
+        # Freezes the list of loaded plugins and invokes the +after_initialize+
+        # callback for each plugin
+        def after_initialize_with_loaded_plugins #:nodoc:
+          add_loaded_plugins
+          Rails.plugins.freeze
+          Rails.plugins.each {|plugin| plugin.after_initialize}
+          
+          after_initialize_without_loaded_plugins
+        end
+        
+        # Adds all of the loaded plugins that were missed to +Rails.plugins+
+        def add_loaded_plugins
+          loaded_plugins.reverse.each do |name|
+            if !Rails.plugins[name] && path = find_plugin_path(name)
+              Rails.plugins.insert(0, Plugin.new(path))
+            end
+          end
+        end
+        
+        private
+        # Finds the path of the specified plugin
+        def find_plugin_path(name)
+          find_plugins(configuration.plugin_paths).find {|path| Plugin.name_for(path) == name}
+        end
+      end
+    end
+  end
+end
+
+Rails::Initializer.class_eval do
+  include PluginAWeek::LoadedPlugins::Extensions::Initializer
+end

data/lib/loaded_plugins/extensions/rails.rb

@@ -0,0 +1,6 @@
+module Rails
+  # A list of all the plugins that have been loaded so far, in the order which
+  # they were *completely* loaded
+  mattr_accessor :plugins
+  self.plugins = PluginList.new
+end

data/lib/loaded_plugins/plugin.rb

@@ -0,0 +1,77 @@
+# An instance of Plugin is created for each plugin loaded by Rails, and
+# stored in the +Rails.plugins+ list
+class Plugin
+  # The name of this plugin
+  attr_accessor :name
+  
+  # The directory in which this plugin is located
+  attr_accessor :root
+  
+  class << self
+    # Gets the name of the plugin, given the path to it.  The following would
+    # return "plugin_xyz":
+    # * plugin_xyz
+    # * plugin_xyz-1.2
+    # * plugin_xyz-1.2.0
+    # * plugin_xyz-1.2.0-win32
+    def name_for(path)
+      name = File.basename(path)
+      /^(.+)-#{Gem::Version::NUM_RE}(-.+)?$/.match(name) && $1 || name
+    end
+  end
+  
+  def initialize(root) #:nodoc:
+    root.chop! if root.ends_with?('/')
+    
+    @root = root
+    @name = self.class.name_for(root)
+  end
+  
+  # The path to the plugin's lib folder
+  def lib_path
+    "#{root}/lib"
+  end
+  
+  # Does the plugin's lib path exist?
+  def lib_path?
+    File.exists?(lib_path)
+  end
+  
+  # Gets all of the plugins that were loaded before this one
+  def plugins_before
+    if Rails.plugins.first == self
+      []
+    else
+      Rails.plugins[0..Rails.plugins.index(self)-1]
+    end
+  end
+  
+  # Gets all of the plugins that were loaded after this one
+  def plugins_after
+    if Rails.plugins.last == self
+      []
+    else
+      Rails.plugins[Rails.plugins.index(self)+1..Rails.plugins.length-1]
+    end
+  end
+  
+  # Invoked immediately before +Rails::Initializer+ loads the plugin
+  def before_load
+  end
+  
+  # Invoked immediately after +Rails::Initializer+ loads the plugin
+  def after_load
+  end
+  
+  # Invoked during the +Rails::Initializer#after_initialize+ callback
+  def after_initialize
+  end
+  
+  def ==(other_obj) #:nodoc:
+    if other_obj.is_a?(Plugin)
+      other_obj.name == name
+    else
+      other_obj.to_s == name
+    end
+  end
+end

data/lib/loaded_plugins/plugin_list.rb

@@ -0,0 +1,53 @@
+# The PluginList class is an array, enhanced to allow access to loaded plugins
+# by name, and iteration over loaded plugins in order of priority.
+#
+# 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.
+class PluginList < Array
+  # Finds plugins with the given name or index.  For example,
+  # 
+  #   Rails.plugins[0]      # => The first plugin loaded
+  #   Rails.plugins[:foo]   # => The "foo" plugin
+  #   Rails.plugins['foo']  # => The "foo" plugin
+  # 
+  # This will return an instance of the +Plugin+ class.
+  def [](name)
+    if name.is_a?(String) || name.is_a?(Symbol)
+      self.find {|plugin| plugin.name.to_s == name.to_s}
+    else
+      super
+    end
+  end
+  
+  # Gets the plugins in the specified comma-delimited list.  If the list is
+  # not specified (i.e. nil), then all plugins are returned.
+  # 
+  # If a specific plugin cannot be found, an exception will be raised indicating
+  # so.
+  def find_by_names(names = nil)
+    if names
+      plugins = names.split(',')
+      missing_plugins = plugins - map(&:name)
+      
+      raise ArgumentError, "Couldn't find plugin(s): #{missing_plugins.to_sentence}" if missing_plugins.any?
+      plugins.collect! {|name| self[name]}
+    else
+      plugins = self
+    end
+    
+    plugins
+  end
+  
+  # Iterates through each plugin by priority.  The last loaded plugin will
+  # always have the highest priority.
+  # 
+  # Effectively, this is like +Rails.plugins.reverse+.  When given a block, it
+  # behaves like +Rails.plugins.reverse.each+.
+  def by_precedence(&block)
+    if block_given?
+      reverse.each { |x| yield x }
+    else 
+      reverse
+    end
+  end
+end

data/test/app_root/config/boot.rb

@@ -0,0 +1,28 @@
+# Don't change this file. Configuration is done in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+unless defined?(Rails::Initializer)
+  require 'rubygems'
+
+  if defined?(RAILS_GEM_VERSION) && version = RAILS_GEM_VERSION
+    # Asking for 1.1.6 will give you 1.1.6.5206, if available -- makes it easier to use beta gems
+    rails_gem = Gem.cache.search('rails', "~>#{version}.0").sort_by { |g| g.version.version }.last
+
+    if rails_gem
+      gem "rails", "=#{rails_gem.version.version}"
+      require rails_gem.full_gem_path + '/lib/initializer'
+    else
+      STDERR.puts %(Cannot find gem for Rails ~>#{version}.0:
+    Install the missing gem with 'gem install -v=#{version} rails', or
+    change environment.rb to define RAILS_GEM_VERSION with your desired version.
+  )
+      exit 1
+    end
+  else
+    require_gem "rails"
+    require 'initializer'
+  end
+
+  Rails::Initializer.run(:set_load_path)
+end

data/test/app_root/vendor/plugins/a_plugin_with_dependencies/init.rb

@@ -0,0 +1 @@
+load_plugin(find_plugins(configuration.plugin_paths).find {|path| path =~ /\/dependent_plugin$/})

data/test/app_root/vendor/plugins/first_plugin/init.rb

@@ -0,0 +1,7 @@
+require 'first_plugin'
+
+module ::Rails
+  mattr_accessor :initializer
+end
+
+::Rails.initializer = self

data/test/app_root/vendor/plugins/second_plugin_with_dependencies/init.rb

@@ -0,0 +1 @@
+load_plugin(find_plugins(configuration.plugin_paths).find {|path| path =~ /\/second_plugins_dependency$/})

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+# Load the environment
+ENV['RAILS_ENV'] ||= 'test'
+require File.dirname(__FILE__) + '/app_root/config/boot'
+
+# Load the plugin
+$:.unshift("#{File.dirname(__FILE__)}/../lib")
+require 'loaded_plugins'
+
+# Load the testing framework
+require 'test/unit'
+
+# Helper methods
+class Test::Unit::TestCase
+  protected
+  def plugins_path
+    "#{RAILS_ROOT}/vendor/plugins"
+  end
+  
+  def plugin_path(name)
+    "#{plugins_path}/#{name}"
+  end
+end

data/test/unit/initializer_test.rb

@@ -0,0 +1,138 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class Rails::Initializer
+  public :find_plugin_path
+end
+
+class Plugin
+  attr_accessor :callbacks
+  
+  def initialize_with_callbacks(*args)
+    @callbacks = []
+    initialize_without_callbacks(*args)
+  end
+  alias_method_chain :initialize, :callbacks
+  
+  def before_load
+    callbacks << :before_load
+  end
+  
+  def after_load
+    callbacks << :after_load
+  end
+  
+  def after_initialize
+    callbacks << :after_initialize
+  end
+end
+
+class LoadedPluginsTest < Test::Unit::TestCase
+  def setup
+    Rails.plugins = PluginList.new
+    @original_load_path = $LOAD_PATH.clone
+    @config = Rails::Configuration.new
+    @config.plugin_paths = [plugins_path]
+    @initializer = Rails::Initializer.new(@config)
+  end
+  
+  def test_should_find_plugin_path_if_plugin_exists
+    assert_equal plugin_path('first_plugin'), @initializer.find_plugin_path('first_plugin')
+  end
+  
+  def test_should_not_find_plugin_path_if_plugin_doesnt_exist
+    assert_nil @initializer.find_plugin_path('nonexistent_plugin')
+  end
+  
+  def test_should_track_plugin_when_loaded
+    @initializer.load_plugin(plugin_path('first_plugin'))
+    assert_not_nil Rails.plugins[:first_plugin]
+  end
+  
+  def test_should_track_multiple_plugins_when_loaded
+    @initializer.load_plugin(plugin_path('first_plugin'))
+    @initializer.load_plugin(plugin_path('plugin_with_only_init'))
+    assert_not_nil Rails.plugins[:first_plugin]
+    assert_not_nil Rails.plugins[:plugin_with_only_init]
+  end
+  
+  def test_should_not_track_plugin_if_already_loaded
+    @initializer.load_plugin(plugin_path('first_plugin'))
+    @initializer.load_plugin(plugin_path('first_plugin'))
+    assert_equal 1, Rails.plugins.size
+  end
+  
+  def test_should_maintain_order_if_plugin_loaded_from_another_plugin
+    @initializer.load_plugin(plugin_path('a_plugin_with_dependencies'))
+    assert_equal %w(dependent_plugin a_plugin_with_dependencies), Rails.plugins.map(&:name)
+  end
+  
+  def test_should_invoke_plugin_callbacks_during_load
+    @initializer.load_plugin(plugin_path('first_plugin'))
+    expected = [
+      :before_load,
+      :after_load
+    ]
+    
+    assert_equal expected, Rails.plugins[:first_plugin].callbacks
+  end
+  
+  def test_should_load_missed_plugins_after_initialize
+    expected = %w(
+      dependent_plugin
+      a_plugin_with_dependencies
+      first_plugin
+      plugin_with_lib_and_init
+      plugin_with_only_init
+      plugin_with_only_lib
+      second_plugins_dependency
+      second_plugin_with_dependencies
+    )
+    
+    @initializer.instance_variable_set('@loaded_plugins', expected)
+    @initializer.after_initialize
+    assert_equal expected, Rails.plugins.map(&:name)
+  end
+  
+  def test_should_freeze_plugin_list_after_initialize
+    @initializer.load_plugins
+    @initializer.after_initialize
+    
+    assert Rails.plugins.frozen?
+  end
+  
+  def test_should_invoke_callbacks_after_initialize
+    @initializer.load_plugins
+    @initializer.after_initialize
+    
+    expected = [
+      :before_load,
+      :after_load,
+      :after_initialize
+    ]
+    assert_equal expected, Rails.plugins[:first_plugin].callbacks
+  end
+  
+  def test_should_user_plugin_names_and_paths_when_tracking
+    @initializer.load_plugins
+    
+    expected = [
+      ['dependent_plugin', plugin_path('dependent_plugin')],
+      ['a_plugin_with_dependencies', plugin_path('a_plugin_with_dependencies')],
+      ['first_plugin', plugin_path('first_plugin')],
+      ['plugin_with_lib_and_init', plugin_path('plugin_with_lib_and_init')],
+      ['plugin_with_only_init', plugin_path('plugin_with_only_init')],
+      ['plugin_with_only_lib', plugin_path('plugin_with_only_lib')],
+      ['second_plugins_dependency', plugin_path('second_plugins_dependency')],
+      ['second_plugin_with_dependencies', plugin_path('second_plugin_with_dependencies')]
+    ]
+    
+    Rails.plugins.each_with_index do |plugin, index|
+      assert_equal expected[index][0], plugin.name
+      assert_equal expected[index][1], plugin.root
+    end
+  end
+  
+  def teardown
+    $LOAD_PATH.replace(@original_load_path)
+  end
+end

data/test/unit/plugin_list_test.rb

@@ -0,0 +1,61 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class PluginListTest < Test::Unit::TestCase
+  def setup
+    @plugin_list = PluginList.new
+    @plugin_list << (@first_plugin = Plugin.new('/path/to/first_plugin'))
+    @plugin_list << (@second_plugin = Plugin.new('/path/to/second_plugin'))
+  end
+  
+  def test_should_index_by_position
+    assert_equal @first_plugin, @plugin_list[0]
+    assert_equal @second_plugin, @plugin_list[1]
+  end
+  
+  def test_should_index_by_symbol_name
+    assert_equal @first_plugin, @plugin_list[:first_plugin]
+  end
+  
+  def test_should_index_by_string_name
+    assert_equal @first_plugin, @plugin_list['first_plugin']
+  end
+  
+  def test_should_return_nil_if_indexed_plugin_name_not_found
+    assert_nil @plugin_list[:invalid_plugin]
+  end
+  
+  def test_should_find_all_plugins_if_no_names_specified
+    assert_equal @plugin_list, @plugin_list.find_by_names
+  end
+  
+  def test_should_find_plugin_if_single_plugin_specified
+    assert_equal [@first_plugin], @plugin_list.find_by_names('first_plugin')
+  end
+  
+  def test_should_find_multiple_plugins_if_multiple_plugins_specified
+    assert_equal [@first_plugin, @second_plugin], @plugin_list.find_by_names('first_plugin,second_plugin')
+  end
+  
+  def test_should_not_find_any_plugins_if_empty
+    assert_equal [], PluginList.new.find_by_names
+  end
+  
+  def test_should_raise_exception_if_invalid_plugin_searched_for
+    assert_raise(ArgumentError) {@plugin_list.find_by_names('invalid_plugin')}
+  end
+  
+  def test_should_raise_exception_if_valid_and_invalid_plugins_searched_for
+    assert_raise(ArgumentError) {@plugin_list.find_by_names('first_plugin,invalid_plugin,second_plugin')}
+  end
+  
+  def test_by_precedence_should_reverse_order
+    assert_equal @plugin_list.reverse, @plugin_list.by_precedence
+  end
+  
+  def test_by_precedence_should_iterate_if_block_given
+    counter = 0
+    @plugin_list.by_precedence {|plugin| counter += 1 }
+    
+    assert_equal @plugin_list.size, counter
+  end
+end

data/test/unit/plugin_test.rb

@@ -0,0 +1,115 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class PluginTest < Test::Unit::TestCase
+  def setup
+    Rails.plugins = PluginList.new
+  end
+  
+  def test_should_parse_name_without_version
+    assert_equal 'plugin', Plugin.name_for('plugin')
+  end
+  
+  def test_should_parse_name_with_major_version
+    assert_equal 'plugin', Plugin.name_for('plugin-1.2')
+  end
+  
+  def test_should_parse_name_with_minor_version
+    assert_equal 'plugin', Plugin.name_for('plugin-1.2.0')
+  end
+  
+  def test_should_parse_name_with_version_and_os
+    assert_equal 'plugin', Plugin.name_for('plugin-1.2.0-win32')
+  end
+  
+  def test_should_use_plugin_path_for_root
+    assert_equal '/path/to/plugin', Plugin.new('/path/to/plugin').root
+  end
+  
+  def test_should_truncate_root_with_trailing_slash
+    assert_equal '/path/to/plugin', Plugin.new('/path/to/plugin/').root
+  end
+  
+  def test_should_use_base_name_for_name
+    assert_equal 'plugin', Plugin.new('/path/to/plugin').name
+  end
+  
+  def test_should_use_parsed_base_name_without_version_for_name
+    assert_equal 'plugin', Plugin.new('/path/to/plugin-1.2.0').name
+  end
+  
+  def test_should_use_parsed_base_name_without_version_and_os_for_name
+    assert_equal 'plugin', Plugin.new('/path/to/plugin-1.2.0-win32').name
+  end
+  
+  def test_lib_path_should_be_relative_to_root
+    assert_equal '/path/to/plugin/lib', Plugin.new('/path/to/plugin').lib_path
+  end
+  
+  def test_lib_path_should_be_false_if_nonexistent
+    assert !Plugin.new('/path/to/plugin').lib_path?
+  end
+  
+  def test_lib_path_should_be_true_if_it_exists
+    assert Plugin.new(plugin_path('first_plugin')).lib_path?
+  end
+  
+  def test_should_have_no_plugins_before_if_first_plugin
+    Rails.plugins << (plugin = Plugin.new('/path/to/plugin'))
+    assert_equal [], plugin.plugins_before
+  end
+  
+  def test_should_have_plugins_before_if_not_first_plugin
+    Rails.plugins << (first_plugin = Plugin.new('/path/to/first_plugin'))
+    Rails.plugins << (second_plugin = Plugin.new('/path/to/second_plugin'))
+    expected = [first_plugin]
+    
+    assert_equal expected, second_plugin.plugins_before
+  end
+  
+  def test_should_have_plugins_before_if_last_plugin
+    Rails.plugins << (first_plugin = Plugin.new('/path/to/first_plugin'))
+    Rails.plugins << (second_plugin = Plugin.new('/path/to/second_plugin'))
+    Rails.plugins << (third_plugin = Plugin.new('/path/to/third_plugin'))
+    expected = [first_plugin, second_plugin]
+    
+    assert_equal expected, third_plugin.plugins_before
+  end
+  
+  def test_should_have_plugins_after_if_first_plugin
+    Rails.plugins << (first_plugin = Plugin.new('/path/to/first_plugin'))
+    Rails.plugins << (second_plugin = Plugin.new('/path/to/second_plugin'))
+    Rails.plugins << (third_plugin = Plugin.new('/path/to/third_plugin'))
+    expected = [second_plugin, third_plugin]
+    
+    assert_equal expected, first_plugin.plugins_after
+  end
+  
+  def test_should_have_plugins_after_if_not_last_plugin
+    Rails.plugins << (first_plugin = Plugin.new('/path/to/first_plugin'))
+    Rails.plugins << (second_plugin = Plugin.new('/path/to/second_plugin'))
+    expected = [second_plugin]
+    
+    assert_equal expected, first_plugin.plugins_after
+  end
+  
+  def test_should_have_no_plugins_after_if_last_plugin
+    Rails.plugins << (plugin = Plugin.new('/path/to/plugin'))
+    assert_equal [], plugin.plugins_after
+  end
+  
+  def test_should_be_equal_if_same_base_name
+    assert Plugin.new('/path/to/plugin') == Plugin.new('/different/path/to/plugin')
+  end
+  
+  def test_should_not_be_equal_if_different_base_name
+    assert Plugin.new('/path/to/plugin') != Plugin.new('/different/path/to/different_plugin')
+  end
+  
+  def test_should_be_equal_if_compared_with_stringified_version_of_plugin_name
+    assert Plugin.new('/path/to/plugin') == 'plugin'
+  end
+  
+  def test_should_not_be_equal_if_compared_with_stringified_version_of_different_plugin_name
+    assert Plugin.new('/path/to/plugin') != 'different_plugin'
+  end
+end

data/test/unit/rails_test.rb

@@ -0,0 +1,8 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class RailsTest < Test::Unit::TestCase
+  def test_should_store_plugins_list
+    assert_not_nil Rails.plugins
+    assert_instance_of PluginList, Rails.plugins
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: loaded_plugins
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+  prerelease: 
+platform: ruby
+authors:
+- Aaron Pfeifer, Neil Abraham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-09 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: info@pluginaweek.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/loaded_plugins.rb
+- lib/loaded_plugins/plugin.rb
+- lib/loaded_plugins/plugin_list.rb
+- lib/loaded_plugins/extensions/initializer.rb
+- lib/loaded_plugins/extensions/rails.rb
+- test/test_helper.rb
+- test/app_root/vendor/plugins/a_plugin_with_dependencies/init.rb
+- test/app_root/vendor/plugins/plugin_with_only_lib/lib/empty
+- test/app_root/vendor/plugins/first_plugin/init.rb
+- test/app_root/vendor/plugins/first_plugin/lib/first_plugin.rb
+- test/app_root/vendor/plugins/second_plugins_dependency/init.rb
+- test/app_root/vendor/plugins/dependent_plugin/init.rb
+- test/app_root/vendor/plugins/plugin_with_lib_and_init/init.rb
+- test/app_root/vendor/plugins/plugin_with_lib_and_init/lib/empty
+- test/app_root/vendor/plugins/subfolder/plugin_with_lib_and_init/init.rb
+- test/app_root/vendor/plugins/subfolder/plugin_with_lib_and_init/lib/empty
+- test/app_root/vendor/plugins/second_plugin_with_dependencies/init.rb
+- test/app_root/vendor/plugins/plugin_with_only_init/init.rb
+- test/app_root/vendor/plugins/invalid_plugin/empty
+- test/app_root/config/boot.rb
+- test/unit/plugin_list_test.rb
+- test/unit/plugin_test.rb
+- test/unit/rails_test.rb
+- test/unit/initializer_test.rb
+- CHANGELOG
+- init.rb
+- MIT-LICENSE
+- Rakefile
+- README
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Adds Rails.plugins, a list all of the plugins that Rails has loaded
+test_files: []