mirrors
/
rails
mirror of https://github.com/rails/rails
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Refactor plugins

This commit is contained in:
Yehuda Katz + Carl Lerche 2009-11-06 17:21:39 -08:00
parent fca32eb6c5
commit 82b9b151ff
19 changed files with 322 additions and 1145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -27,6 +27,7 @@ railties/guides/output
*.rbc
*.swp
*.swo
*.tmproj
bin
vendor/gems/
railties/tmp

12
railties/lib/rails.rb
View File

@ -1 +1,13 @@
require "pathname"
require 'rails/initializable'
require 'rails/application'
require 'rails/railties_path'
require 'rails/version'
require 'rails/rack'
require 'rails/paths'
require 'rails/core'
require 'rails/configuration'
require 'rails/deprecation'
require 'rails/initializer'
require 'rails/plugin'

50
railties/lib/rails/application.rb
View File

@ -23,10 +23,6 @@ module Rails
@config = config
end
def plugin_loader
@plugin_loader ||= config.plugin_loader.new(self)
end
def root
config.root
end
@ -37,7 +33,7 @@ module Rails
end
def initialize
run_initializers
run_initializers(self)
end
def config
@ -46,10 +42,6 @@ module Rails
alias configuration config
def plugin_loader
self.class.plugin_loader
end
def middleware
config.middleware
end
@ -58,6 +50,18 @@ module Rails
ActionController::Routing::Routes
end
def initializers
initializers = super
plugins.each { |p| initializers += p.initializers }
initializers
end
def plugins
@plugins ||= begin
Plugin::Vendored.all(config.plugins || [:all], config.paths.vendor.plugins)
end
end
def call(env)
@app ||= middleware.build(routes)
@app.call(env)
@ -111,13 +115,6 @@ module Rails
config.load_once_paths.freeze
end
# Adds all load paths from plugins to the global set of load paths, so that
# code from plugins can be required (explicitly or automatically via ActiveSupport::Dependencies).
initializer :add_plugin_load_paths do
require 'active_support/dependencies'
plugin_loader.add_plugin_load_paths
end
# Create tmp directories
initializer :ensure_tmp_directories_exist do
%w(cache pids sessions sockets).each do |dir_to_make|
@ -321,7 +318,6 @@ module Rails
# TODO: Make Rails and metal work without ActionController
if config.frameworks.include?(:action_controller)
Rails::Rack::Metal.requested_metals = config.metals
Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths
config.middleware.insert_before(
:"ActionDispatch::ParamsParser",
@ -329,26 +325,6 @@ module Rails
end
end
# Loads all plugins in <tt>config.plugin_paths</tt>. <tt>plugin_paths</tt>
# defaults to <tt>vendor/plugins</tt> but may also be set to a list of
# paths, such as
# config.plugin_paths = ["#{config.root}/lib/plugins", "#{config.root}/vendor/plugins"]
#
# In the default implementation, as each plugin discovered in <tt>plugin_paths</tt> is initialized:
# * its +lib+ directory, if present, is added to the load path (immediately after the applications lib directory)
# * <tt>init.rb</tt> is evaluated, if present
#
# After all plugins are loaded, duplicates are removed from the load path.
# If an array of plugin names is specified in config.plugins, only those plugins will be loaded
# and they plugins will be loaded in that order. Otherwise, plugins are loaded in alphabetical
# order.
#
# if config.plugins ends contains :all then the named plugins will be loaded in the given order and all other
# plugins will be loaded in alphabetical order
initializer :load_plugins do
plugin_loader.load_plugins
end
# # bail out if gems are missing - note that check_gem_dependencies will have
# # already called abort() unless $gems_rake_task is set
# return unless gems_dependencies_loaded

33
railties/lib/rails/configuration.rb
View File

@ -1,17 +1,13 @@
require 'rails/plugin/loader'
require 'rails/plugin/locator'
require 'active_support/ordered_options'
module Rails
class Configuration
attr_accessor :cache_classes, :load_paths,
:load_once_paths, :after_initialize_blocks,
:frameworks, :framework_root_path, :root, :plugin_paths, :plugins,
:plugin_loader, :plugin_locators, :gems, :loaded_plugins, :reload_plugins,
attr_accessor :cache_classes, :load_paths, :load_once_paths, :after_initialize_blocks,
:frameworks, :framework_root_path, :root, :gems, :plugins,
:i18n, :gems, :whiny_nils, :consider_all_requests_local,
:action_controller, :active_record, :action_view, :active_support,
:action_mailer, :active_resource,
:log_path, :log_level, :logger, :preload_frameworks,
:reload_plugins, :log_path, :log_level, :logger, :preload_frameworks,
:database_configuration_file, :cache_store, :time_zone,
:view_path, :metals, :controller_paths, :routes_configuration_file,
:eager_load_paths, :dependency_loading, :paths, :serve_static_assets
@ -19,7 +15,6 @@ module Rails
def initialize
@load_once_paths = []
@after_initialize_blocks = []
@loaded_plugins = []
@dependency_loading = true
@serve_static_assets = true
@ -199,24 +194,6 @@ module Rails
@frameworks ||= [ :active_record, :action_controller, :action_view, :action_mailer, :active_resource ]
end
def plugin_paths
@plugin_paths ||= ["#{root}/vendor/plugins"]
end
def plugin_loader
@plugin_loader ||= begin
Plugin::Loader
end
end
def plugin_locators
@plugin_locators ||= begin
locators = []
locators << Plugin::GemLocator if defined? Gem
locators << Plugin::FileSystemLocator
end
end
def i18n
@i18n ||= begin
i18n = ActiveSupport::OrderedOptions.new
@ -235,10 +212,6 @@ module Rails
"#{root}/config/environments/#{RAILS_ENV}.rb"
end
def reload_plugins?
@reload_plugins
end
# Holds generators configuration:
#
# config.generators do |g|

3
railties/lib/rails/initializable.rb
View File

@ -42,7 +42,8 @@ module Rails
if initializer.before
index = index_for(initializer.before)
elsif initializer.after
index = index_for(initializer.after) + 1
index = index_for(initializer.after)
index += 1 if index
else
index = length
end

12
railties/lib/rails/initializer.rb
View File

@ -1,14 +1,4 @@
require "pathname"
require 'rails/initializable'
require 'rails/application'
require 'rails/railties_path'
require 'rails/version'
require 'rails/rack'
require 'rails/paths'
require 'rails/core'
require 'rails/configuration'
require 'rails/deprecation'
require "rails" # In case people require this file directly
RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)

6
railties/lib/rails/paths.rb
View File

@ -64,7 +64,7 @@ module Rails
end
class Path
include PathParent
include PathParent, Enumerable
attr_reader :path
attr_accessor :glob
@ -83,6 +83,10 @@ module Rails
@root.all_paths << self
end
def each
to_a.each { |p| yield p }
end
def push(path)
@paths.push path
end

219
railties/lib/rails/plugin.rb
View File

@ -1,183 +1,64 @@
module Rails
# The Plugin class should be an object which provides the following methods:
#
# * +name+ - Used during initialisation to order the plugin (based on name and
# the contents of <tt>config.plugins</tt>).
# * +valid?+ - Returns true if this plugin can be loaded.
# * +load_paths+ - Each path within the returned array will be added to the <tt>$LOAD_PATH</tt>.
# * +load+ - Finally 'load' the plugin.
#
# These methods are expected by the Rails::Plugin::Locator and Rails::Plugin::Loader classes.
# The default implementation returns the <tt>lib</tt> directory as its <tt>load_paths</tt>,
# and evaluates <tt>init.rb</tt> when <tt>load</tt> is called.
#
# You can also inspect the about.yml data programmatically:
#
# plugin = Rails::Plugin.new(path_to_my_plugin)
# plugin.about["author"] # => "James Adam"
# plugin.about["url"] # => "http://interblah.net"
class Plugin
include Comparable
include Initializable
attr_reader :directory, :name
def initialize(directory)
@directory = directory
@name = File.basename(@directory) rescue nil
@loaded = false
end
def valid?
File.directory?(directory) && (has_app_directory? || has_lib_directory? || has_init_file?)
end
# Returns a list of paths this plugin wishes to make available in <tt>$LOAD_PATH</tt>.
def load_paths
report_nonexistant_or_empty_plugin! unless valid?
load_paths = []
load_paths << lib_path if has_lib_directory?
load_paths << app_paths if has_app_directory?
load_paths.flatten
end
# Evaluates a plugin's init.rb file.
def load(initializer)
return if loaded?
report_nonexistant_or_empty_plugin! unless valid?
evaluate_init_rb(initializer)
@loaded = true
end
def loaded?
@loaded
end
def <=>(other_plugin)
name <=> other_plugin.name
end
def about
@about ||= load_about_information
end
# Engines are plugins with an app/ directory.
def engine?
has_app_directory?
end
# Returns true if the engine ships with a routing file
def routed?
File.exist?(routing_file)
end
# Returns true if there is any localization file in locale_path
def localized?
locale_files.any?
end
def view_path
File.join(directory, 'app', 'views')
end
def controller_path
File.join(directory, 'app', 'controllers')
end
def metal_path
File.join(directory, 'app', 'metal')
end
def routing_file
File.join(directory, 'config', 'routes.rb')
end
def locale_path
File.join(directory, 'config', 'locales')
end
def locale_files
Dir[ File.join(locale_path, '*.{rb,yml}') ]
end
private
def load_about_information
about_yml_path = File.join(@directory, "about.yml")
parsed_yml = File.exist?(about_yml_path) ? YAML.load(File.read(about_yml_path)) : {}
parsed_yml || {}
rescue Exception
{}
end
def report_nonexistant_or_empty_plugin!
raise LoadError, "Can not find the plugin named: #{name}"
end
def app_paths
[ File.join(directory, 'app', 'models'), File.join(directory, 'app', 'helpers'), controller_path, metal_path ]
end
def lib_path
File.join(directory, 'lib')
end
def classic_init_path
File.join(directory, 'init.rb')
end
def gem_init_path
File.join(directory, 'rails', 'init.rb')
end
def init_path
File.file?(gem_init_path) ? gem_init_path : classic_init_path
end
def has_app_directory?
File.directory?(File.join(directory, 'app'))
end
def has_lib_directory?
File.directory?(lib_path)
end
def has_init_file?
File.file?(init_path)
end
def evaluate_init_rb(initializer)
if has_init_file?
require 'active_support/core_ext/kernel/reporting'
silence_warnings do
# Allow plugins to reference the current configuration object
config = initializer.configuration
eval(IO.read(init_path), binding, init_path)
end
end
end
class Vendored < Plugin
initializer :init_rb do |application|
evaluate_init_rb(application)
def self.all(list, paths)
plugins = []
paths.each do |path|
Dir["#{path}/*"].each do |plugin_path|
plugin = new(plugin_path)
next unless list.include?(plugin.name) || list.include?(:all)
plugins << plugin
end
end
plugins.sort_by do |p|
[list.index(p.name) || list.index(:all), p.name.to_s]
end
end
attr_reader :name, :path
def initialize(path)
@name = File.basename(path).to_sym
@path = path
end
def load_paths
Dir["#{path}/{lib}", "#{path}/app/{models,controllers,helpers}"]
end
initializer :add_to_load_path, :after => :set_autoload_paths do |app|
load_paths.each do |path|
$LOAD_PATH << path
require "active_support/dependencies"
ActiveSupport::Dependencies.load_paths << path
unless app.config.reload_plugins
ActiveSupport::Dependencies.load_once_paths << path
end
end
end
# This Plugin subclass represents a Gem plugin. Although RubyGems has already
# taken care of $LOAD_PATHs, it exposes its load_paths to add them
# to Dependencies.load_paths.
class GemPlugin < Plugin
# Initialize this plugin from a Gem::Specification.
def initialize(spec, gem)
directory = spec.full_gem_path
super(directory)
@name = spec.name
initializer :load_init_rb, :before => :load_application_initializers do |app|
file = "#{@path}/init.rb"
config = app.config
eval File.read(file), binding, file if File.file?(file)
end
def init_path
File.join(directory, 'rails', 'init.rb')
initializer :add_view_paths, :after => :initialize_framework_views do
ActionController::Base.view_paths.concat ["#{path}/app/views"] if File.directory?("#{path}/app/views")
end
initializer :add_routing_file, :after => :initialize_routing do |app|
routing_file = "#{path}/config/routes.rb"
if File.exist?(routing_file)
app.routes.add_configuration_file(routing_file)
app.routes.reload!
end
end
end
end
end

200
railties/lib/rails/plugin/loader.rb
View File

@ -1,200 +0,0 @@
require "rails/plugin"
module Rails
class Plugin
class Loader
attr_reader :initializer
# Creates a new Plugin::Loader instance, associated with the given
# Rails::Initializer. This default implementation automatically locates
# all plugins, and adds all plugin load paths, when it is created. The plugins
# are then fully loaded (init.rb is evaluated) when load_plugins is called.
#
# It is the loader's responsibility to ensure that only the plugins specified
# in the configuration are actually loaded, and that the order defined
# is respected.
def initialize(initializer)
@initializer = initializer
end
# Returns the plugins to be loaded, in the order they should be loaded.
def plugins
@plugins ||= all_plugins.select { |plugin| should_load?(plugin) }.sort { |p1, p2| order_plugins(p1, p2) }
end
# Returns the plugins that are in engine-form (have an app/ directory)
def engines
@engines ||= plugins.select {|plugin| plugin.engine? }
end
# Returns all the plugins that could be found by the current locators.
def all_plugins
@all_plugins ||= locate_plugins
@all_plugins
end
def load_plugins
plugins.each do |plugin|
plugin.load(initializer)
register_plugin_as_loaded(plugin)
end
configure_engines
ensure_all_registered_plugins_are_loaded!
end
# Adds the load paths for every plugin into the $LOAD_PATH. Plugin load paths are
# added *after* the application's <tt>lib</tt> directory, to ensure that an application
# can always override code within a plugin.
#
# Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.
def add_plugin_load_paths
plugins.each do |plugin|
plugin.load_paths.each do |path|
$LOAD_PATH.insert(application_lib_index + 1, path)
ActiveSupport::Dependencies.load_paths << path
unless configuration.reload_plugins?
ActiveSupport::Dependencies.load_once_paths << path
end
end
end
$LOAD_PATH.uniq!
end
def engine_metal_paths
engines.collect {|engine| engine.metal_path }
end
protected
def configure_engines
if engines.any?
add_engine_routing_configurations
add_engine_locales
add_engine_controller_paths
add_engine_view_paths
end
end
def add_engine_routing_configurations
engines.select {|engine| engine.routed? }.map {|engine| engine.routing_file }.each do |routing_file|
ActionController::Routing::Routes.add_configuration_file(routing_file)
end
end
def add_engine_locales
localized_engines = engines.select { |engine| engine.localized? }
# reverse it such that the last engine can overwrite translations from the first, like with routes
locale_files = localized_engines.collect { |engine| engine.locale_files }.reverse.flatten
I18n.load_path += locale_files - I18n.load_path
end
def add_engine_controller_paths
ActionController::Routing.controller_paths += engines.collect {|engine| engine.controller_path }
end
def add_engine_view_paths
# reverse it such that the last engine can overwrite view paths from the first, like with routes
paths = ActionView::PathSet.new(engines.collect {|engine| engine.view_path }.reverse)
ActionController::Base.view_paths.concat(paths)
ActionMailer::Base.view_paths.concat(paths) if configuration.frameworks.include?(:action_mailer)
end
# The locate_plugins method uses each class in config.plugin_locators to
# find the set of all plugins available to this Rails application.
def locate_plugins
configuration.plugin_locators.map do |locator|
locator.new(initializer).plugins
end.flatten
# TODO: sorting based on config.plugins
end
def register_plugin_as_loaded(plugin)
initializer.config.loaded_plugins << plugin
end
def configuration
initializer.configuration
end
def should_load?(plugin)
# uses Plugin#name and Plugin#valid?
enabled?(plugin) && plugin.valid?
end
def order_plugins(plugin_a, plugin_b)
if !explicit_plugin_loading_order?
plugin_a <=> plugin_b
else
if !explicitly_enabled?(plugin_a) && !explicitly_enabled?(plugin_b)
plugin_a <=> plugin_b
else
effective_order_of(plugin_a) <=> effective_order_of(plugin_b)
end
end
end
def effective_order_of(plugin)
if explicitly_enabled?(plugin)
registered_plugin_names.index(plugin.name)
else
registered_plugin_names.index('all')
end
end
def application_lib_index
$LOAD_PATH.index(File.join(Rails.root, 'lib')) || 0
end
def enabled?(plugin)
!explicit_plugin_loading_order? || registered?(plugin)
end
def explicit_plugin_loading_order?
!registered_plugin_names.nil?
end
def registered?(plugin)
explicit_plugin_loading_order? && registered_plugins_names_plugin?(plugin)
end
def explicitly_enabled?(plugin)
!explicit_plugin_loading_order? || explicitly_registered?(plugin)
end
def explicitly_registered?(plugin)
explicit_plugin_loading_order? && registered_plugin_names.include?(plugin.name)
end
def registered_plugins_names_plugin?(plugin)
registered_plugin_names.include?(plugin.name) || registered_plugin_names.include?('all')
end
# The plugins that have been explicitly listed with config.plugins. If this list is nil
# then it means the client does not care which plugins or in what order they are loaded,
# so we load all in alphabetical order. If it is an empty array, we load no plugins, if it is
# non empty, we load the named plugins in the order specified.
def registered_plugin_names
configuration.plugins ? configuration.plugins.map {|plugin| plugin.to_s } : nil
end
def loaded?(plugin_name)
initializer.config.loaded_plugins.detect { |plugin| plugin.name == plugin_name.to_s }
end
def ensure_all_registered_plugins_are_loaded!
if explicit_plugin_loading_order?
if configuration.plugins.detect {|plugin| plugin != :all && !loaded?(plugin) }
missing_plugins = configuration.plugins - (plugins.map{|p| p.name.to_sym} + [:all])
raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence(:locale => :en)}"
end
end
end
end
end
end

100
railties/lib/rails/plugin/locator.rb
View File

@ -1,100 +0,0 @@
module Rails
class Plugin
# The Plugin::Locator class should be subclasses to provide custom plugin-finding
# abilities to Rails (i.e. loading plugins from Gems, etc). Each subclass should implement
# the <tt>located_plugins</tt> method, which return an array of Plugin objects that have been found.
class Locator
include Enumerable
attr_reader :initializer
def initialize(initializer)
@initializer = initializer
end
# This method should return all the plugins which this Plugin::Locator can find
# These will then be used by the current Plugin::Loader, which is responsible for actually
# loading the plugins themselves
def plugins
raise "The `plugins' method must be defined by concrete subclasses of #{self.class}"
end
def each(&block)
plugins.each(&block)
end
def plugin_names
plugins.map {|plugin| plugin.name }
end
end
# The Rails::Plugin::FileSystemLocator will try to locate plugins by examining the directories
# in the paths given in configuration.plugin_paths. Any plugins that can be found are returned
# in a list.
#
# The criteria for a valid plugin in this case is found in Rails::Plugin#valid?, although
# other subclasses of Rails::Plugin::Locator can of course use different conditions.
class FileSystemLocator < Locator
# Returns all the plugins which can be loaded in the filesystem, under the paths given
# by configuration.plugin_paths.
def plugins
initializer.configuration.plugin_paths.flatten.inject([]) do |plugins, path|
plugins.concat locate_plugins_under(path)
plugins
end.flatten
end
private
# Attempts to create a plugin from the given path. If the created plugin is valid?
# (see Rails::Plugin#valid?) then the plugin instance is returned; otherwise nil.
def create_plugin(path)
plugin = Rails::Plugin.new(path)
plugin.valid? ? plugin : nil
end
# This starts at the base path looking for valid plugins (see Rails::Plugin#valid?).
# Since plugins can be nested arbitrarily deep within an unspecified number of intermediary
# directories, this method runs recursively until it finds a plugin directory, e.g.
#
# locate_plugins_under('vendor/plugins/acts/acts_as_chunky_bacon')
# => <Rails::Plugin name: 'acts_as_chunky_bacon' ... >
#
def locate_plugins_under(base_path)
Dir.glob(File.join(base_path, '*')).sort.inject([]) do |plugins, path|
if plugin = create_plugin(path)
plugins << plugin
elsif File.directory?(path)
plugins.concat locate_plugins_under(path)
end
plugins
end
end
end
# The GemLocator scans all the loaded RubyGems, looking for gems with
# a <tt>rails/init.rb</tt> file.
class GemLocator < Locator
def plugins
gem_index = {}
specs = gem_index.keys
specs += Gem.loaded_specs.values.select do |spec|
spec.loaded_from && # prune stubs
File.exist?(File.join(spec.full_gem_path, "rails", "init.rb"))
end
specs.compact!
require "rubygems/dependency_list"
deps = Gem::DependencyList.new
deps.add(*specs) unless specs.empty?
deps.dependency_order.collect do |spec|
Rails::GemPlugin.new(spec, gem_index[spec])
end
end
end
end
end

117
railties/test/application/plugins_test.rb
View File

@ -1,117 +0,0 @@
require "isolation/abstract_unit"
module ApplicationTests
class PluginTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
def assert_plugins(list_of_names, array_of_plugins, message=nil)
assert_equal list_of_names.map { |n| n.to_s }, array_of_plugins.map { |p| p.name }, message
end
def setup
build_app
boot_rails
require "rails"
@failure_tip = "It's likely someone has added a new plugin fixture without updating this list"
# Tmp hax to get tests working
FileUtils.cp_r "#{File.dirname(__FILE__)}/../fixtures/plugins", "#{app_path}/vendor"
end
test "all plugins are loaded when registered plugin list is untouched" do
Rails::Initializer.run { |c| c.root = app_path }
Rails.initialize!
assert_plugins [
:a, :acts_as_chunky_bacon, :engine, :gemlike, :plugin_with_no_lib_dir, :stubby
], Rails.application.config.loaded_plugins, @failure_tip
end
test "no plugins are loaded if the configuration has an empty plugin list" do
Rails::Initializer.run { |c| c.root = app_path; c.plugins = [] }
assert_plugins [], Rails.application.config.loaded_plugins
end
test "only the specified plugins are located in the order listed" do
plugin_names = [:plugin_with_no_lib_dir, :acts_as_chunky_bacon]
Rails::Initializer.run { |c| c.root = app_path; c.plugins = plugin_names }
Rails.initialize!
assert_plugins plugin_names, Rails.application.config.loaded_plugins
end
test "all plugins loaded after all" do
Rails::Initializer.run do |config|
config.root = app_path
config.plugins = [:stubby, :all, :acts_as_chunky_bacon]
end
Rails.initialize!
assert_plugins [:stubby, :a, :engine, :gemlike, :plugin_with_no_lib_dir, :acts_as_chunky_bacon], Rails.application.config.loaded_plugins, @failure_tip
end
test "plugin names may be strings" do
plugin_names = ['stubby', 'acts_as_chunky_bacon', :a, :plugin_with_no_lib_dir]
Rails::Initializer.run do |config|
config.root = app_path
config.plugins = ['stubby', 'acts_as_chunky_bacon', :a, :plugin_with_no_lib_dir]
end
Rails.initialize!
assert_plugins plugin_names, Rails.application.config.loaded_plugins, @failure_tip
end
test "all plugins loaded when all is used" do
Rails::Initializer.run do |config|
config.root = app_path
config.plugins = [:stubby, :acts_as_chunky_bacon, :all]
end
Rails.initialize!
assert_plugins [:stubby, :acts_as_chunky_bacon, :a, :engine, :gemlike, :plugin_with_no_lib_dir], Rails.application.config.loaded_plugins, @failure_tip
end
test "all loaded plugins are added to the load paths" do
Rails::Initializer.run do |config|
config.root = app_path
config.plugins = [:stubby, :acts_as_chunky_bacon]
end
Rails.initialize!
assert $LOAD_PATH.include?("#{app_path}/vendor/plugins/default/stubby/lib")
assert $LOAD_PATH.include?("#{app_path}/vendor/plugins/default/acts/acts_as_chunky_bacon/lib")
end
test "registering a plugin name that does not exist raises a load error" do
Rails::Initializer.run do |config|
config.root = app_path
config.plugins = [:stubby, :acts_as_a_non_existant_plugin]
end
assert_raise(LoadError) do
Rails.initialize!
end
end
test "load error messages mention missing plugins and no others" do
valid_plugins = [:stubby, :acts_as_chunky_bacon]
invalid_plugins = [:non_existant_plugin1, :non_existant_plugin2]
begin
Rails::Initializer.run do |config|
config.root = app_path
config.plugins = [:stubby, :acts_as_chunky_bacon, :non_existant_plugin1, :non_existant_plugin2]
end
Rails.initialize!
flunk "Expected a LoadError but did not get one"
rescue LoadError => e
assert_plugins valid_plugins, Rails.application.config.loaded_plugins, @failure_tip
invalid_plugins.each do |plugin|
assert_match(/#{plugin.to_s}/, e.message, "LoadError message should mention plugin '#{plugin}'")
end
valid_plugins.each do |plugin|
assert_no_match(/#{plugin.to_s}/, e.message, "LoadError message should not mention '#{plugin}'")
end
end
end
end
end

8
railties/test/initializable_test.rb
View File

@ -94,6 +94,10 @@ module InitializableTests
include Rails::Initializable
initializer :startup, :before => :last do
$arr << 3
end
initializer :terminate, :after => :first do
$arr << two
end
@ -109,7 +113,7 @@ module InitializableTests
end
initializer :last do
$arr << 3
$arr << 4
end
def self.initializers
@ -189,7 +193,7 @@ module InitializableTests
test "merges in the initializers from the parent in the right order" do
$arr = []
OverriddenInitializer.new.run_initializers
assert_equal [1, 2, 3], $arr
assert_equal [1, 2, 3, 4], $arr
end
end
end

42
railties/test/initializer/initialize_i18n_test.rb
View File

@ -30,27 +30,27 @@ module InitializerTests
end
test "i18n finds locale files in engines" do
app_file "vendor/plugins/engine/init.rb", ""
app_file "vendor/plugins/engine/app/models/hellos.rb", "class Hello ; end"
app_file "vendor/plugins/engine/lib/omg.rb", "puts 'omg'"
app_file "vendor/plugins/engine/config/locales/en.yml", "hello:"
Rails::Initializer.run do |c|
c.root = app_path
c.i18n.load_path << "my/other/locale.yml"
end
Rails.initialize!
#{RAILS_FRAMEWORK_ROOT}/railties/test/fixtures/plugins/engines/engine/config/locales/en.yml
assert_equal %W(
#{RAILS_FRAMEWORK_ROOT}/activesupport/lib/active_support/locale/en.yml
#{RAILS_FRAMEWORK_ROOT}/activemodel/lib/active_model/locale/en.yml
#{RAILS_FRAMEWORK_ROOT}/activerecord/lib/active_record/locale/en.yml
#{RAILS_FRAMEWORK_ROOT}/actionpack/lib/action_view/locale/en.yml
#{app_path}/config/locales/en.yml
my/other/locale.yml
#{app_path}/vendor/plugins/engine/config/locales/en.yml
).map { |path| File.expand_path(path) }, I18n.load_path.map { |path| File.expand_path(path) }
# app_file "vendor/plugins/engine/init.rb", ""
# app_file "vendor/plugins/engine/app/models/hellos.rb", "class Hello ; end"
# app_file "vendor/plugins/engine/lib/omg.rb", "puts 'omg'"
# app_file "vendor/plugins/engine/config/locales/en.yml", "hello:"
#
# Rails::Initializer.run do |c|
# c.root = app_path
# c.i18n.load_path << "my/other/locale.yml"
# end
# Rails.initialize!
#
# #{RAILS_FRAMEWORK_ROOT}/railties/test/fixtures/plugins/engines/engine/config/locales/en.yml
# assert_equal %W(
# #{RAILS_FRAMEWORK_ROOT}/activesupport/lib/active_support/locale/en.yml
# #{RAILS_FRAMEWORK_ROOT}/activemodel/lib/active_model/locale/en.yml
# #{RAILS_FRAMEWORK_ROOT}/activerecord/lib/active_record/locale/en.yml
# #{RAILS_FRAMEWORK_ROOT}/actionpack/lib/action_view/locale/en.yml
# #{app_path}/config/locales/en.yml
# my/other/locale.yml
# #{app_path}/vendor/plugins/engine/config/locales/en.yml
# ).map { |path| File.expand_path(path) }, I18n.load_path.map { |path| File.expand_path(path) }
end
end
end

28
railties/test/isolation/abstract_unit.rb
View File

@ -92,6 +92,34 @@ module TestHelpers
add_to_config 'config.action_controller.session = { :key => "_myapp_session", :secret => "bac838a849c1d5c4de2e6a50af826079" }'
end
class Bukkit
def initialize(path)
@path = path
end
def write(file, string)
path = "#{@path}/#{file}"
FileUtils.mkdir_p(File.dirname(path))
File.open(path, "w") {|f| f.puts string }
end
def delete(file)
File.delete("#{@path}/#{file}")
end
end
def plugin(name, string = "")
dir = "#{app_path}/vendor/plugins/#{name}"
FileUtils.mkdir_p(dir)
File.open("#{dir}/init.rb", 'w') do |f|
f.puts "::#{name.upcase} = 'loaded'"
f.puts string
end
Bukkit.new(dir).tap do |bukkit|
yield bukkit if block_given?
end
end
def script(script)
Dir.chdir(app_path) do
`#{Gem.ruby} #{app_path}/script/#{script}`

176
railties/test/plugin_loader_test.rb
View File

@ -1,176 +0,0 @@
require 'plugin_test_helper'
$:.unshift File.dirname(__FILE__) + "/../../actionpack/lib"
$:.unshift File.dirname(__FILE__) + "/../../actionmailer/lib"
require 'action_controller'
require 'action_mailer'
# TODO: Rewrite all these tests
class FakeInitializerSlashApplication
attr_reader :config
alias configuration config
def initialize
@config = Rails::Configuration.new
end
end
class TestPluginLoader < Test::Unit::TestCase
ORIGINAL_LOAD_PATH = $LOAD_PATH.dup
def setup
reset_load_path!
@initializer = FakeInitializerSlashApplication.new
@configuration = @initializer.config
Rails.application = @initializer
@configuration.plugin_paths << plugin_fixture_root_path
@valid_plugin_path = plugin_fixture_path('default/stubby')
@empty_plugin_path = plugin_fixture_path('default/empty')
@failure_tip = "It's likely someone has added a new plugin fixture without updating this list"
@loader = Rails::Plugin::Loader.new(@initializer)
end
def test_should_locate_plugins_by_asking_each_locator_specifed_in_configuration_for_its_plugins_result
locator_1 = stub(:plugins => [:a, :b, :c])
locator_2 = stub(:plugins => [:d, :e, :f])
locator_class_1 = stub(:new => locator_1)
locator_class_2 = stub(:new => locator_2)
@configuration.plugin_locators = [locator_class_1, locator_class_2]
assert_equal [:a, :b, :c, :d, :e, :f], @loader.send(:locate_plugins)
end
def test_should_memoize_the_result_of_locate_plugins_as_all_plugins
plugin_list = [:a, :b, :c]
@loader.expects(:locate_plugins).once.returns(plugin_list)
assert_equal plugin_list, @loader.all_plugins
assert_equal plugin_list, @loader.all_plugins # ensuring that locate_plugins isn't called again
end
def test_should_return_empty_array_if_configuration_plugins_is_empty
@configuration.plugins = []
assert_equal [], @loader.plugins
end
def test_should_find_all_availble_plugins_and_return_as_all_plugins
assert_plugins [ :engine, :stubby, :plugin_with_no_lib_dir, :gemlike, :acts_as_chunky_bacon, :a], @loader.all_plugins.reverse, @failure_tip
end
def test_should_return_all_plugins_as_plugins_when_registered_plugin_list_is_untouched
assert_plugins [:a, :acts_as_chunky_bacon, :engine, :gemlike, :plugin_with_no_lib_dir, :stubby], @loader.plugins, @failure_tip
end
def test_should_return_all_plugins_as_plugins_when_registered_plugin_list_is_nil
@configuration.plugins = nil
assert_plugins [:a, :acts_as_chunky_bacon, :engine, :gemlike, :plugin_with_no_lib_dir, :stubby], @loader.plugins, @failure_tip
end
def test_should_return_specific_plugins_named_in_config_plugins_array_if_set
plugin_names = [:acts_as_chunky_bacon, :stubby]
only_load_the_following_plugins! plugin_names
assert_plugins plugin_names, @loader.plugins
end
def test_should_respect_the_order_of_plugins_given_in_configuration
plugin_names = [:stubby, :acts_as_chunky_bacon]
only_load_the_following_plugins! plugin_names
assert_plugins plugin_names, @loader.plugins
end
def test_should_load_all_plugins_in_natural_order_when_all_is_used
only_load_the_following_plugins! [:all]
assert_plugins [:a, :acts_as_chunky_bacon, :engine, :gemlike, :plugin_with_no_lib_dir, :stubby], @loader.plugins, @failure_tip
end
def test_should_load_specified_plugins_in_order_and_then_all_remaining_plugins_when_all_is_used
only_load_the_following_plugins! [:stubby, :acts_as_chunky_bacon, :all]
assert_plugins [:stubby, :acts_as_chunky_bacon, :a, :engine, :gemlike, :plugin_with_no_lib_dir], @loader.plugins, @failure_tip
end
def test_should_be_able_to_specify_loading_of_plugins_loaded_after_all
only_load_the_following_plugins! [:stubby, :all, :acts_as_chunky_bacon]
assert_plugins [:stubby, :a, :engine, :gemlike, :plugin_with_no_lib_dir, :acts_as_chunky_bacon], @loader.plugins, @failure_tip
end
def test_should_accept_plugin_names_given_as_strings
only_load_the_following_plugins! ['stubby', 'acts_as_chunky_bacon', :a, :plugin_with_no_lib_dir]
assert_plugins [:stubby, :acts_as_chunky_bacon, :a, :plugin_with_no_lib_dir], @loader.plugins, @failure_tip
end
def test_should_add_plugin_load_paths_to_global_LOAD_PATH_array
only_load_the_following_plugins! [:stubby, :acts_as_chunky_bacon]
stubbed_application_lib_index_in_LOAD_PATHS = 4
@loader.stubs(:application_lib_index).returns(stubbed_application_lib_index_in_LOAD_PATHS)
@loader.add_plugin_load_paths
assert $LOAD_PATH.index(File.join(plugin_fixture_path('default/stubby'), 'lib')) >= stubbed_application_lib_index_in_LOAD_PATHS
assert $LOAD_PATH.index(File.join(plugin_fixture_path('default/acts/acts_as_chunky_bacon'), 'lib')) >= stubbed_application_lib_index_in_LOAD_PATHS
end
def test_should_add_plugin_load_paths_to_Dependencies_load_paths
only_load_the_following_plugins! [:stubby, :acts_as_chunky_bacon]
@loader.add_plugin_load_paths
assert ActiveSupport::Dependencies.load_paths.include?(File.join(plugin_fixture_path('default/stubby'), 'lib'))
assert ActiveSupport::Dependencies.load_paths.include?(File.join(plugin_fixture_path('default/acts/acts_as_chunky_bacon'), 'lib'))
end
def test_should_add_engine_load_paths_to_Dependencies_load_paths
only_load_the_following_plugins! [:engine]
@loader.add_plugin_load_paths
%w( models controllers metal helpers ).each do |app_part|
assert ActiveSupport::Dependencies.load_paths.include?(
File.join(plugin_fixture_path('engines/engine'), 'app', app_part)
), "Couldn't find #{app_part} in load path"
end
end
def test_engine_controllers_and_action_mailers_should_have_their_view_path_set_when_loaded
only_load_the_following_plugins!([ :engine ])
@loader.send :add_engine_view_paths
assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views') ], ActionController::Base.view_paths.map { |p| p.to_s }
assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views') ], ActionMailer::Base.view_paths.map { |p| p.to_s }
end
def test_should_add_plugin_load_paths_to_Dependencies_load_once_paths
only_load_the_following_plugins! [:stubby, :acts_as_chunky_bacon]
@loader.add_plugin_load_paths
assert ActiveSupport::Dependencies.load_once_paths.include?(File.join(plugin_fixture_path('default/stubby'), 'lib'))
assert ActiveSupport::Dependencies.load_once_paths.include?(File.join(plugin_fixture_path('default/acts/acts_as_chunky_bacon'), 'lib'))
end
def test_should_add_all_load_paths_from_a_plugin_to_LOAD_PATH_array
plugin_load_paths = ["a", "b"]
plugin = stub(:load_paths => plugin_load_paths)
@loader.stubs(:plugins).returns([plugin])
@loader.add_plugin_load_paths
plugin_load_paths.each { |path| assert $LOAD_PATH.include?(path) }
end
def test_should_add_locale_files_to_I18n_load_path
only_load_the_following_plugins! [:engine]
@loader.send :add_engine_locales
assert I18n.load_path.include?(File.join(plugin_fixture_path('engines/engine'), 'config', 'locales', 'en.yml'))
end
private
def reset_load_path!
$LOAD_PATH.clear
ORIGINAL_LOAD_PATH.each { |path| $LOAD_PATH << path }
end
end

73
railties/test/plugin_locator_test.rb
View File

@ -1,73 +0,0 @@
require 'plugin_test_helper'
# TODO: Rewrite all these tests
class FakeInitializerSlashApplication
attr_reader :config
alias configuration config
def initialize
@config = Rails::Configuration.new
end
end
class PluginLocatorTest < Test::Unit::TestCase
def test_should_require_subclasses_to_implement_the_plugins_method
assert_raise(RuntimeError) do
Rails::Plugin::Locator.new(nil).plugins
end
end
def test_should_iterator_over_plugins_returned_by_plugins_when_calling_each
locator = Rails::Plugin::Locator.new(nil)
locator.stubs(:plugins).returns([:a, :b, :c])
plugin_consumer = mock
plugin_consumer.expects(:consume).with(:a)
plugin_consumer.expects(:consume).with(:b)
plugin_consumer.expects(:consume).with(:c)
locator.each do |plugin|
plugin_consumer.consume(plugin)
end
end
end
class PluginFileSystemLocatorTest < Test::Unit::TestCase
def setup
@initializer = FakeInitializerSlashApplication.new
@configuration = @initializer.config
Rails.application = @initializer
# We need to add our testing plugin directory to the plugin paths so
# the locator knows where to look for our plugins
@configuration.plugin_paths << plugin_fixture_root_path
@locator = Rails::Plugin::FileSystemLocator.new(@initializer)
@valid_plugin_path = plugin_fixture_path('default/stubby')
@empty_plugin_path = plugin_fixture_path('default/empty')
end
def test_should_return_rails_plugin_instances_when_calling_create_plugin_with_a_valid_plugin_directory
assert_kind_of Rails::Plugin, @locator.send(:create_plugin, @valid_plugin_path)
end
def test_should_return_nil_when_calling_create_plugin_with_an_invalid_plugin_directory
assert_nil @locator.send(:create_plugin, @empty_plugin_path)
end
def test_should_return_all_plugins_found_under_the_set_plugin_paths
assert_equal ["a", "acts_as_chunky_bacon", "engine", "gemlike", "plugin_with_no_lib_dir", "stubby"].sort, @locator.plugins.map { |p| p.name }.sort
end
def test_should_find_plugins_only_under_the_plugin_paths_set_in_configuration
@configuration.plugin_paths = [File.join(plugin_fixture_root_path, "default")]
assert_equal ["acts_as_chunky_bacon", "gemlike", "plugin_with_no_lib_dir", "stubby"].sort, @locator.plugins.map { |p| p.name }.sort
@configuration.plugin_paths = [File.join(plugin_fixture_root_path, "alternate")]
assert_equal ["a"], @locator.plugins.map { |p| p.name }
end
def test_should_not_raise_any_error_and_return_no_plugins_if_the_plugin_path_value_does_not_exist
@configuration.plugin_paths = ["some_missing_directory"]
assert_nothing_raised do
assert @locator.plugins.empty?
end
end
end

174
railties/test/plugin_test.rb
View File

@ -1,174 +0,0 @@
require 'plugin_test_helper'
# TODO: Rewrite all these tests
class FakeInitializerSlashApplication
attr_reader :config
alias configuration config
def initialize
@config = Rails::Configuration.new
end
end
class PluginTest < Test::Unit::TestCase
def setup
@initializer = FakeInitializerSlashApplication.new
@configuration = @initializer.config
Rails.application = @initializer
@valid_plugin_path = plugin_fixture_path('default/stubby')
@empty_plugin_path = plugin_fixture_path('default/empty')
@gemlike_plugin_path = plugin_fixture_path('default/gemlike')
end
def test_should_determine_plugin_name_from_the_directory_of_the_plugin
assert_equal 'stubby', plugin_for(@valid_plugin_path).name
assert_equal 'empty', plugin_for(@empty_plugin_path).name
end
def test_should_not_be_loaded_when_created
assert !plugin_for(@valid_plugin_path).loaded?
end
def test_should_be_marked_as_loaded_when_load_is_called
plugin = plugin_for(@valid_plugin_path)
assert !plugin.loaded?
plugin.stubs(:evaluate_init_rb)
assert_nothing_raised do
plugin.send(:load, anything)
end
assert plugin.loaded?
end
def test_should_determine_validity_of_given_path
# This is a plugin path, with a lib dir
assert plugin_for(@valid_plugin_path).valid?
# This just has an init.rb and no lib dir
assert plugin_for(plugin_fixture_path('default/plugin_with_no_lib_dir')).valid?
# This would be a plugin path, but the directory is empty
assert !plugin_for(plugin_fixture_path('default/empty')).valid?
# This is a non sense path
assert !plugin_for(plugin_fixture_path('default/this_directory_does_not_exist')).valid?
end
def test_should_return_empty_array_for_load_paths_when_plugin_has_no_lib_directory
assert_equal [], plugin_for(plugin_fixture_path('default/plugin_with_no_lib_dir')).load_paths
end
def test_should_return_array_with_lib_path_for_load_paths_when_plugin_has_a_lib_directory
expected_lib_dir = File.join(plugin_fixture_path('default/stubby'), 'lib')
assert_equal [expected_lib_dir], plugin_for(plugin_fixture_path('default/stubby')).load_paths
end
def test_should_raise_a_load_error_when_trying_to_determine_the_load_paths_from_an_invalid_plugin
assert_nothing_raised do
plugin_for(@valid_plugin_path).load_paths
end
assert_raise(LoadError) do
plugin_for(@empty_plugin_path).load_paths
end
assert_raise(LoadError) do
plugin_for('this_is_not_a_plugin_directory').load_paths
end
end
def test_should_raise_a_load_error_when_trying_to_load_an_invalid_plugin
# This path is fine so nothing is raised
assert_nothing_raised do
plugin = plugin_for(@valid_plugin_path)
plugin.stubs(:evaluate_init_rb)
plugin.send(:load, @initializer)
end
# This path is fine so nothing is raised
assert_nothing_raised do
plugin = plugin_for(@gemlike_plugin_path)
plugin.stubs(:evaluate_init_rb)
plugin.send(:load, @initializer)
end
# This is an empty path so it raises
assert_raise(LoadError) do
plugin = plugin_for(@empty_plugin_path)
plugin.stubs(:evaluate_init_rb)
plugin.send(:load, @initializer)
end
assert_raise(LoadError) do
plugin = plugin_for('this_is_not_a_plugin_directory')
plugin.stubs(:evaluate_init_rb)
plugin.send(:load, @initializer)
end
end
def test_should_raise_a_load_error_when_trying_to_access_load_paths_of_an_invalid_plugin
# This path is fine so nothing is raised
assert_nothing_raised do
plugin_for(@valid_plugin_path).load_paths
end
# This is an empty path so it raises
assert_raise(LoadError) do
plugin_for(@empty_plugin_path).load_paths
end
assert_raise(LoadError) do
plugin_for('this_is_not_a_plugin_directory').load_paths
end
end
def test_loading_a_plugin_gives_the_init_file_access_to_all_it_needs
failure_tip = "Perhaps someone has written another test that loads this same plugin and therefore makes the StubbyMixin constant defined already."
assert !defined?(StubbyMixin), failure_tip
plugin = plugin_for(@valid_plugin_path)
plugin.load_paths.each { |path| $LOAD_PATH.unshift(path) }
# The init.rb of this plugin raises if it doesn't have access to all the things it needs
assert_nothing_raised do
plugin.load(@initializer)
end
assert defined?(StubbyMixin)
end
def test_should_sort_naturally_by_name
a = plugin_for("path/a")
b = plugin_for("path/b")
z = plugin_for("path/z")
assert_equal [a, b, z], [b, z, a].sort
end
def test_should_only_be_loaded_once
plugin = plugin_for(@valid_plugin_path)
assert !plugin.loaded?
plugin.expects(:evaluate_init_rb)
assert_nothing_raised do
plugin.send(:load, @initializer)
plugin.send(:load, @initializer)
end
assert plugin.loaded?
end
def test_should_make_about_yml_available_as_about_method_on_plugin
plugin = plugin_for(@valid_plugin_path)
assert_equal "Plugin Author", plugin.about['author']
assert_equal "1.0.0", plugin.about['version']
end
def test_should_return_empty_hash_for_about_if_about_yml_is_missing
assert_equal({}, plugin_for(about_yml_plugin_path('plugin_without_about_yaml')).about)
end
def test_should_return_empty_hash_for_about_if_about_yml_is_malformed
assert_equal({}, plugin_for(about_yml_plugin_path('bad_about_yml')).about)
end
private
def about_yml_plugin_path(name)
File.join(File.dirname(__FILE__), 'fixtures', 'about_yml_plugins', name)
end
def plugin_for(path)
Rails::Plugin.new(path)
end
end

29
railties/test/plugin_test_helper.rb
View File

@ -1,29 +0,0 @@
$:.unshift File.dirname(__FILE__) + "/../lib"
$:.unshift File.dirname(__FILE__) + "/../../activesupport/lib"
require 'test/unit'
require 'active_support'
require 'rails/initializer'
require 'abstract_unit'
# We need to set RAILS_ROOT if it isn't already set
RAILS_ROOT = '.' unless defined?(RAILS_ROOT)
class Test::Unit::TestCase
private
def plugin_fixture_root_path
File.expand_path(File.join(File.dirname(__FILE__), 'fixtures', 'plugins'))
end
def only_load_the_following_plugins!(plugins)
@initializer.configuration.plugins = plugins
end
def plugin_fixture_path(path)
File.join(plugin_fixture_root_path, path)
end
def assert_plugins(list_of_names, array_of_plugins, message=nil)
assert_equal list_of_names.map { |n| n.to_s }, array_of_plugins.map { |p| p.name }, message
end
end

190
railties/test/plugins/vendored_test.rb
View File

@ -1,19 +1,195 @@
require "isolation/abstract_unit"
module ApplicationTests
class PluginTest < Test::Unit::TestCase
module PluginsTest
class VendoredTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
def setup
build_app
@plugin = plugin "bukkits", "::LEVEL = config.log_level" do |plugin|
plugin.write "lib/bukkits.rb", "class Bukkits; end"
end
end
test "generates the plugin" do
script "generate plugin my_plugin"
File.open("#{app_path}/vendor/plugins/my_plugin/init.rb", 'w') do |f|
f.puts "OMG = 'hello'"
end
def boot_rails
super
require "#{app_path}/config/environment"
end
test "it loads the plugin's init.rb file" do
boot_rails
assert_equal "loaded", BUKKITS
end
test "the init.rb file has access to the config object" do
boot_rails
assert_equal :debug, LEVEL
end
test "the plugin puts its lib directory on the load path" do
boot_rails
require "bukkits"
assert_equal "Bukkits", Bukkits.name
end
test "plugin paths get added to the AS::Dependency list" do
boot_rails
assert_equal "Bukkits", Bukkits.name
end
test "plugin constants do not get reloaded by default" do
boot_rails
assert_equal "Bukkits", Bukkits.name
ActiveSupport::Dependencies.clear
@plugin.delete("lib/bukkits.rb")
assert_nothing_raised { Bukkits }
end
test "plugin constants get reloaded if config.reload_plugins is set" do
add_to_config <<-RUBY
config.reload_plugins = true
RUBY
boot_rails
assert_equal "Bukkits", Bukkits.name
ActiveSupport::Dependencies.clear
@plugin.delete("lib/bukkits.rb")
assert_raises(NameError) { Bukkits }
end
test "plugin should work without init.rb" do
@plugin.delete("init.rb")
boot_rails
require "bukkits"
assert_nothing_raised { Bukkits }
end
test "the plugin puts its models directory on the load path" do
@plugin.write "app/models/my_bukkit.rb", "class MyBukkit ; end"
boot_rails
assert_nothing_raised { MyBukkit }
end
test "the plugin puts is controllers directory on the load path" do
@plugin.write "app/controllers/bukkit_controller.rb", "class BukkitController ; end"
boot_rails
assert_nothing_raised { BukkitController }
end
test "the plugin adds its view to the load path" do
@plugin.write "app/controllers/bukkit_controller.rb", <<-RUBY
class BukkitController < ActionController::Base
def index
end
end
RUBY
@plugin.write "app/views/bukkit/index.html.erb", "Hello bukkits"
boot_rails
require "action_controller"
require "rack/mock"
response = BukkitController.action(:index).call(Rack::MockRequest.env_for("/"))
assert_equal "Hello bukkits\n", response[2].body
end
test "the plugin adds helpers to the controller's views" do
@plugin.write "app/controllers/bukkit_controller.rb", <<-RUBY
class BukkitController < ActionController::Base
def index
end
end
RUBY
@plugin.write "app/helpers/bukkit_helper.rb", <<-RUBY
module BukkitHelper
def bukkits
"bukkits"
end
end
RUBY
@plugin.write "app/views/bukkit/index.html.erb", "Hello <%= bukkits %>"
boot_rails
require "rack/mock"
response = BukkitController.action(:index).call(Rack::MockRequest.env_for("/"))
assert_equal "Hello bukkits\n", response[2].body
end
test "routes.rb are added to the router" do
@plugin.write "config/routes.rb", <<-RUBY
class Sprokkit
def self.call(env)
[200, {'Content-Type' => 'text/html'}, ["I am a Sprokkit"]]
end
end
ActionController::Routing::Routes.draw do
match "/sprokkit", :to => Sprokkit
end
RUBY
boot_rails
require "rack/mock"
response = Rails.application.call(Rack::MockRequest.env_for("/sprokkit"))
assert_equal "I am a Sprokkit", response[2].join
end
end
class VendoredOrderingTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
def setup
build_app
$arr = []
plugin "a_plugin", "$arr << :a"
plugin "b_plugin", "$arr << :b"
plugin "c_plugin", "$arr << :c"
end
def boot_rails
super
require "#{app_path}/config/environment"
end
test "plugins are loaded alphabetically by default" do
boot_rails
assert_equal [:a, :b, :c], $arr
end
test "if specified, only those plugins are loaded" do
add_to_config "config.plugins = [:b_plugin]"
boot_rails
assert_equal [:b], $arr
end
test "the plugins are initialized in the order they are specified" do
add_to_config "config.plugins = [:b_plugin, :a_plugin]"
boot_rails
assert_equal [:b, :a], $arr
end
test "if :all is specified, the remaining plugins are loaded in alphabetical order" do
add_to_config "config.plugins = [:c_plugin, :all]"
boot_rails
assert_equal [:c, :a, :b], $arr
end
test "if :all is at the beginning, it represents the plugins not otherwise specified" do
add_to_config "config.plugins = [:all, :b_plugin]"
boot_rails
assert_equal [:a, :c, :b], $arr
end
end
end