kotovalexarian-likes-github
/
rails--rails
mirror of https://github.com/rails/rails.git
1
0
Fork 0
Code Releases Activity

Finish porting over the initializers to the app object and fix all the tests

This commit is contained in:
Carl Lerche 2009-10-08 18:12:28 -07:00
parent 5c42157cd8
commit 992c2db76c
15 changed files with 482 additions and 837 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
actionpack/lib/action_controller/metal/session_management.rb
View File

@ -16,7 +16,7 @@ module ActionController #:nodoc:
self.session_store = ActiveRecord::SessionStore
else
@@session_store = store.is_a?(Symbol) ?
Session.const_get(store.to_s.camelize) :
ActionDispatch::Session.const_get(store.to_s.camelize) :
store
end
end

7
actionpack/lib/action_view/paths.rb
View File

@ -1,8 +1,11 @@
module ActionView #:nodoc:
class PathSet < Array #:nodoc:
def self.type_cast(obj)
def self.type_cast(obj, cache = nil)
# TODO: Clean this up
if obj.is_a?(String)
cache = !defined?(Rails) || !Rails.respond_to?(:configuration) || Rails.configuration.cache_classes
if cache.nil?
cache = !defined?(Rails) || Rails.application.config.cache_classes
end
FileSystemResolverWithFallback.new(obj, :cache => cache)
else
obj

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

@ -277,5 +277,211 @@ module Rails
end
end
end
# Initializes framework-specific settings for each of the loaded frameworks
# (Configuration#frameworks). The available settings map to the accessors
# on each of the corresponding Base classes.
initializer :initialize_framework_settings do
config.frameworks.each do |framework|
base_class = framework.to_s.camelize.constantize.const_get("Base")
config.send(framework).each do |setting, value|
base_class.send("#{setting}=", value)
end
end
config.active_support.each do |setting, value|
ActiveSupport.send("#{setting}=", value)
end
end
# Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
# (but only for those frameworks that are to be loaded). If the framework's
# paths have already been set, it is not changed, otherwise it is
# set to use Configuration#view_path.
initializer :initialize_framework_views do
if config.frameworks.include?(:action_view)
view_path = ActionView::PathSet.type_cast(config.view_path, config.cache_classes)
ActionMailer::Base.template_root = view_path if config.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
ActionController::Base.view_paths = view_path if config.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
end
end
initializer :initialize_metal do
# 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",
Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
end
end
initializer :check_for_unbuilt_gems do
unbuilt_gems = config.gems.select {|gem| gem.frozen? && !gem.built? }
if unbuilt_gems.size > 0
# don't print if the gems:build rake tasks are being run
unless $gems_build_rake_task
abort <<-end_error
The following gems have native components that need to be built
#{unbuilt_gems.map { |gemm| "#{gemm.name} #{gemm.requirement}" } * "\n "}
You're running:
ruby #{Gem.ruby_version} at #{Gem.ruby}
rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
Run `rake gems:build` to build the unbuilt gems.
end_error
end
end
end
initializer :load_gems do
unless $gems_rake_task
config.gems.each { |gem| gem.load }
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 = ["#{RAILS_ROOT}/lib/plugins", "#{RAILS_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
# TODO: Figure out if this needs to run a second time
# load_gems
initializer :check_gem_dependencies do
unloaded_gems = config.gems.reject { |g| g.loaded? }
if unloaded_gems.size > 0
configuration.gems_dependencies_loaded = false
# don't print if the gems rake tasks are being run
unless $gems_rake_task
abort <<-end_error
Missing these required gems:
#{unloaded_gems.map { |gemm| "#{gemm.name} #{gemm.requirement}" } * "\n "}
You're running:
ruby #{Gem.ruby_version} at #{Gem.ruby}
rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
Run `rake gems:install` to install the missing gems.
end_error
end
else
configuration.gems_dependencies_loaded = true
end
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
initializer :load_application_initializers do
if config.gems_dependencies_loaded
Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
load(initializer)
end
end
end
# Fires the user-supplied after_initialize block (Configuration#after_initialize)
initializer :after_initialize do
if config.gems_dependencies_loaded
configuration.after_initialize_blocks.each do |block|
block.call
end
end
end
# # Setup database middleware after initializers have run
initializer :initialize_database_middleware do
if configuration.frameworks.include?(:active_record)
if configuration.frameworks.include?(:action_controller) && ActionController::Base.session_store &&
ActionController::Base.session_store.name == 'ActiveRecord::SessionStore'
configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement
configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::QueryCache
else
configuration.middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
configuration.middleware.use ActiveRecord::QueryCache
end
end
end
# TODO: Make a DSL way to limit an initializer to a particular framework
# # Prepare dispatcher callbacks and run 'prepare' callbacks
initializer :prepare_dispatcher do
next unless configuration.frameworks.include?(:action_controller)
require 'rails/dispatcher' unless defined?(::Dispatcher)
Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
end
# Routing must be initialized after plugins to allow the former to extend the routes
# ---
# If Action Controller is not one of the loaded frameworks (Configuration#frameworks)
# this does nothing. Otherwise, it loads the routing definitions and sets up
# loading module used to lazily load controllers (Configuration#controller_paths).
initializer :initialize_routing do
next unless configuration.frameworks.include?(:action_controller)
ActionController::Routing.controller_paths += configuration.controller_paths
ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
ActionController::Routing::Routes.reload!
end
#
# # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
initializer :load_observers do
if config.gems_dependencies_loaded && configuration.frameworks.include?(:active_record)
ActiveRecord::Base.instantiate_observers
end
end
# Eager load application classes
initializer :load_application_classes do
next if $rails_rake_task
if configuration.cache_classes
configuration.eager_load_paths.each do |load_path|
matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
require_dependency file.sub(matcher, '\1')
end
end
end
end
# Disable dependency loading during request cycle
initializer :disable_dependency_loading do
if configuration.cache_classes && !configuration.dependency_loading
ActiveSupport::Dependencies.unhook!
end
end
# Configure generators if they were already loaded
# ===
# TODO: Does this need to be an initializer here?
initializer :initialize_generators do
if defined?(Rails::Generators)
Rails::Generators.no_color! unless config.generators.colorize_logging
Rails::Generators.aliases.deep_merge! config.generators.aliases
Rails::Generators.options.deep_merge! config.generators.options
end
end
end
end

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

@ -15,11 +15,7 @@ module Rails
# The Configuration instance used to configure the Rails environment
def configuration
@@configuration
end
def configuration=(configuration)
@@configuration = configuration
application.configuration
end
def initialized?

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

@ -15,308 +15,14 @@ RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)
module Rails
class Initializer
class Error < StandardError ; end
class Base
class << self
def run(&blk)
define_method(:run, &blk)
end
def config=(config)
@@config = config
end
def config
@@config || Configuration.new
end
alias configuration config
def gems_dependencies_loaded
config.gems_dependencies_loaded
end
def plugin_loader
@plugin_loader ||= configuration.plugin_loader.new(self)
end
end
def gems_dependencies_loaded
self.class.gems_dependencies_loaded
end
def plugin_loader
self.class.plugin_loader
end
end
class Runner
attr_reader :names, :initializers
attr_accessor :config
alias configuration config
def initialize(parent = nil)
@names = parent ? parent.names.dup : {}
@initializers = parent ? parent.initializers.dup : []
end
def add(name, options = {}, &block)
# If :before or :after is specified, set the index to the right spot
if other = options[:before] || options[:after]
raise Error, "The #{other.inspect} initializer does not exist" unless @names[other]
index = @initializers.index(@names[other])
index += 1 if options[:after]
end
@initializers.insert(index || -1, block)
@names[name] = block
end
def delete(name)
@names[name].tap do |initializer|
@initializers.delete(initializer)
@names.delete(name)
end
end
def run_initializer(initializer)
init_block = initializer.is_a?(Proc) ? initializer : @names[initializer]
container = Class.new(Base, &init_block).new
container.run if container.respond_to?(:run)
end
def run(initializer = nil)
Rails.configuration = Base.config = @config
if initializer
run_initializer(initializer)
else
@initializers.each {|block| run_initializer(block) }
end
end
end
def self.default
@default ||= Runner.new
end
def self.run(initializer = nil, config = nil)
# TODO: Clean this all up
if initializer
default.config = config
default.run(initializer)
# Deprecated
else
Rails.application = Class.new(Application)
yield Rails.application.config if block_given?
# Trigger the initializer
Rails.application.new
default.config = Rails.application.config
default.run
end
end
end
# Initializes framework-specific settings for each of the loaded frameworks
# (Configuration#frameworks). The available settings map to the accessors
# on each of the corresponding Base classes.
Initializer.default.add :initialize_framework_settings do
configuration.frameworks.each do |framework|
base_class = framework.to_s.camelize.constantize.const_get("Base")
configuration.send(framework).each do |setting, value|
base_class.send("#{setting}=", value)
end
end
configuration.active_support.each do |setting, value|
ActiveSupport.send("#{setting}=", value)
end
end
# Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
# (but only for those frameworks that are to be loaded). If the framework's
# paths have already been set, it is not changed, otherwise it is
# set to use Configuration#view_path.
Initializer.default.add :initialize_framework_views do
if configuration.frameworks.include?(:action_view)
view_path = ActionView::PathSet.type_cast(configuration.view_path)
ActionMailer::Base.template_root = view_path if configuration.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
ActionController::Base.view_paths = view_path if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
end
end
Initializer.default.add :initialize_metal do
# TODO: Make Rails and metal work without ActionController
if configuration.frameworks.include?(:action_controller)
Rails::Rack::Metal.requested_metals = configuration.metals
Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths
configuration.middleware.insert_before(
:"ActionDispatch::ParamsParser",
Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
end
end
Initializer.default.add :check_for_unbuilt_gems do
unbuilt_gems = config.gems.select {|gem| gem.frozen? && !gem.built? }
if unbuilt_gems.size > 0
# don't print if the gems:build rake tasks are being run
unless $gems_build_rake_task
abort <<-end_error
The following gems have native components that need to be built
#{unbuilt_gems.map { |gemm| "#{gemm.name} #{gemm.requirement}" } * "\n "}
You're running:
ruby #{Gem.ruby_version} at #{Gem.ruby}
rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
Run `rake gems:build` to build the unbuilt gems.
end_error
end
end
end
Initializer.default.add :load_gems do
unless $gems_rake_task
config.gems.each { |gem| gem.load }
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 = ["#{RAILS_ROOT}/lib/plugins", "#{RAILS_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.default.add :load_plugins do
plugin_loader.load_plugins
end
# TODO: Figure out if this needs to run a second time
# load_gems
Initializer.default.add :check_gem_dependencies do
unloaded_gems = config.gems.reject { |g| g.loaded? }
if unloaded_gems.size > 0
configuration.gems_dependencies_loaded = false
# don't print if the gems rake tasks are being run
unless $gems_rake_task
abort <<-end_error
Missing these required gems:
#{unloaded_gems.map { |gemm| "#{gemm.name} #{gemm.requirement}" } * "\n "}
You're running:
ruby #{Gem.ruby_version} at #{Gem.ruby}
rubygems #{Gem::RubyGemsVersion} at #{Gem.path * ', '}
Run `rake gems:install` to install the missing gems.
end_error
end
else
configuration.gems_dependencies_loaded = true
end
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
Initializer.default.add :load_application_initializers do
if gems_dependencies_loaded
Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
load(initializer)
end
end
end
# Fires the user-supplied after_initialize block (Configuration#after_initialize)
Initializer.default.add :after_initialize do
if gems_dependencies_loaded
configuration.after_initialize_blocks.each do |block|
block.call
end
end
end
# # Setup database middleware after initializers have run
Initializer.default.add :initialize_database_middleware do
if configuration.frameworks.include?(:active_record)
if configuration.frameworks.include?(:action_controller) && ActionController::Base.session_store &&
ActionController::Base.session_store.name == 'ActiveRecord::SessionStore'
configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement
configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::QueryCache
else
configuration.middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
configuration.middleware.use ActiveRecord::QueryCache
end
end
end
# TODO: Make a DSL way to limit an initializer to a particular framework
# # Prepare dispatcher callbacks and run 'prepare' callbacks
Initializer.default.add :prepare_dispatcher do
next unless configuration.frameworks.include?(:action_controller)
require 'rails/dispatcher' unless defined?(::Dispatcher)
Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
end
# Routing must be initialized after plugins to allow the former to extend the routes
# ---
# If Action Controller is not one of the loaded frameworks (Configuration#frameworks)
# this does nothing. Otherwise, it loads the routing definitions and sets up
# loading module used to lazily load controllers (Configuration#controller_paths).
Initializer.default.add :initialize_routing do
next unless configuration.frameworks.include?(:action_controller)
ActionController::Routing.controller_paths += configuration.controller_paths
ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
ActionController::Routing::Routes.reload!
end
#
# # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
Initializer.default.add :load_observers do
if gems_dependencies_loaded && configuration.frameworks.include?(:active_record)
ActiveRecord::Base.instantiate_observers
end
end
# Eager load application classes
Initializer.default.add :load_application_classes do
next if $rails_rake_task
if configuration.cache_classes
configuration.eager_load_paths.each do |load_path|
matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
require_dependency file.sub(matcher, '\1')
end
end
end
end
# Disable dependency loading during request cycle
Initializer.default.add :disable_dependency_loading do
if configuration.cache_classes && !configuration.dependency_loading
ActiveSupport::Dependencies.unhook!
end
end
# Configure generators if they were already loaded
Initializer.default.add :initialize_generators do
if defined?(Rails::Generators)
Rails::Generators.no_color! unless config.generators.colorize_logging
Rails::Generators.aliases.deep_merge! config.generators.aliases
Rails::Generators.options.deep_merge! config.generators.options
end
end
end

89
railties/test/application/generators_test.rb Normal file
View File

@ -0,0 +1,89 @@
require "isolation/abstract_unit"
module ApplicationTests
class GeneratorsTest < Test::Unit::TestCase
include ActiveSupport::Testing::Isolation
def setup
require "rails/generators"
build_app
boot_rails
end
test "generators default values" do
Rails::Initializer.run do |c|
assert_equal(true, c.generators.colorize_logging)
assert_equal({}, c.generators.aliases)
assert_equal({}, c.generators.options)
end
end
test "generators set rails options" do
Rails::Initializer.run do |c|
c.generators.orm = :datamapper
c.generators.test_framework = :rspec
expected = { :rails => { :orm => :datamapper, :test_framework => :rspec } }
assert_equal(expected, c.generators.options)
end
end
test "generators set rails aliases" do
Rails::Initializer.run do |c|
c.generators.aliases = { :rails => { :test_framework => "-w" } }
expected = { :rails => { :test_framework => "-w" } }
assert_equal expected, c.generators.aliases
end
end
test "generators aliases and options on initialization" do
Rails::Initializer.run do |c|
c.generators.rails :aliases => { :test_framework => "-w" }
c.generators.orm :datamapper
c.generators.test_framework :rspec
end
assert_equal :rspec, Rails::Generators.options[:rails][:test_framework]
assert_equal "-w", Rails::Generators.aliases[:rails][:test_framework]
end
test "generators no color on initialization" do
Rails::Initializer.run do |c|
c.generators.colorize_logging = false
end
assert_equal Thor::Base.shell, Thor::Shell::Basic
end
test "generators with hashes for options and aliases" do
Rails::Initializer.run do |c|
c.generators do |g|
g.orm :datamapper, :migration => false
g.plugin :aliases => { :generator => "-g" },
:generator => true
end
expected = {
:rails => { :orm => :datamapper },
:plugin => { :generator => true },
:datamapper => { :migration => false }
}
assert_equal expected, c.generators.options
assert_equal({ :plugin => { :generator => "-g" } }, c.generators.aliases)
end
end
test "generators with hashes are deep merged" do
Rails::Initializer.run do |c|
c.generators do |g|
g.orm :datamapper, :migration => false
g.plugin :aliases => { :generator => "-g" },
:generator => true
end
end
assert Rails::Generators.aliases.size >= 1
assert Rails::Generators.options.size >= 1
end
end
end

132
railties/test/application/initializer_test.rb
View File

@ -55,6 +55,59 @@ module ApplicationTests
assert Zoo
end
test "load environment with global" do
app_file "config/environments/development.rb", "$initialize_test_set_from_env = 'success'"
assert_nil $initialize_test_set_from_env
Rails::Initializer.run { }
assert_equal "success", $initialize_test_set_from_env
end
test "action_controller load paths set only if action controller in use" do
assert_nothing_raised NameError do
Rails::Initializer.run do |config|
config.frameworks = []
end
end
end
test "action_pack is added to the load path if action_controller is required" do
Rails::Initializer.run do |config|
config.frameworks = [:action_controller]
end
assert $:.include?("#{framework_path}/actionpack/lib")
end
test "action_pack is added to the load path if action_view is required" do
Rails::Initializer.run do |config|
config.frameworks = [:action_view]
end
assert $:.include?("#{framework_path}/actionpack/lib")
end
test "after_initialize block works correctly" do
Rails::Initializer.run do |config|
config.after_initialize { $test_after_initialize_block1 = "success" }
config.after_initialize { $test_after_initialize_block2 = "congratulations" }
end
assert_equal "success", $test_after_initialize_block1
assert_equal "congratulations", $test_after_initialize_block2
end
test "after_initialize block works correctly when no block is passed" do
Rails::Initializer.run do |config|
config.after_initialize { $test_after_initialize_block1 = "success" }
config.after_initialize # don't pass a block, this is what we're testing!
config.after_initialize { $test_after_initialize_block2 = "congratulations" }
end
assert_equal "success", $test_after_initialize_block1
assert_equal "congratulations", $test_after_initialize_block2
end
# i18n
test "setting another default locale" do
Rails::Initializer.run do |config|
config.i18n.default_locale = :de
@ -62,11 +115,80 @@ module ApplicationTests
assert_equal :de, I18n.default_locale
end
test "load environment with global" do
app_file "config/environments/development.rb", "$initialize_test_set_from_env = 'success'"
assert_nil $initialize_test_set_from_env
Rails::Initializer.run { }
assert_equal "success", $initialize_test_set_from_env
test "no config locales dir present should return empty load path" do
FileUtils.rm_rf "#{app_path}/config/locales"
Rails::Initializer.run do |c|
assert_equal [], c.i18n.load_path
end
end
test "config locales dir present should be added to load path" do
Rails::Initializer.run do |c|
assert_equal ["#{app_path}/config/locales/en.yml"], c.i18n.load_path
end
end
test "config defaults should be added with config settings" do
Rails::Initializer.run do |c|
c.i18n.load_path << "my/other/locale.yml"
end
assert_equal [
"#{app_path}/config/locales/en.yml", "my/other/locale.yml"
], Rails.application.config.i18n.load_path
end
# DB middleware
test "database middleware doesn't initialize when session store is not active_record" do
Rails::Initializer.run do |config|
config.action_controller.session_store = :cookie_store
end
assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
end
test "database middleware doesn't initialize when activerecord is not in frameworks" do
Rails::Initializer.run do |c|
c.frameworks = []
end
assert_equal [], Rails.application.config.middleware
end
test "database middleware initializes when session store is active record" do
Rails::Initializer.run do |c|
c.action_controller.session_store = :active_record_store
end
expects = [ActiveRecord::ConnectionAdapters::ConnectionManagement, ActiveRecord::QueryCache, ActiveRecord::SessionStore]
middleware = Rails.application.config.middleware.map { |m| m.klass }
assert_equal expects, middleware & expects
end
test "ensure database middleware doesn't use action_controller on initializing" do
Rails::Initializer.run do |c|
c.frameworks -= [:action_controller]
c.action_controller.session_store = :active_record_store
end
assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
end
# Pathview test
test "load view paths doesn't perform anything when action_view not in frameworks" do
Rails::Initializer.run do |c|
c.frameworks -= [:action_view]
end
assert_equal nil, ActionMailer::Base.template_root
assert_equal [], ActionController::Base.view_paths
end
# Rails root test
test "Rails.root == RAILS_ROOT" do
assert_equal RAILS_ROOT, Rails.root.to_s
end
test "Rails.root should be a Pathname" do
assert_instance_of Pathname, Rails.root
end
end
end

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

@ -23,6 +23,17 @@ module ApplicationTests
], 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.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.plugins = plugin_names }
assert_plugins plugin_names, Rails.application.config.loaded_plugins
end
test "all plugins loaded after all" do
Rails::Initializer.run do |config|
config.plugins = [:stubby, :all, :acts_as_chunky_bacon]

2
railties/test/initializer/path_test.rb
View File

@ -12,7 +12,7 @@ class PathsTest < Test::Unit::TestCase
ActionController::Base.session_store = nil
end
end
@paths = Rails::Initializer.default.config.paths
@paths = Rails.application.config.paths
end
def root(*path)

351
railties/test/initializer_test.rb
View File

@ -6,359 +6,8 @@ require 'action_view'
require 'action_mailer'
require 'active_record'
# Mocks out the configuration
module Rails
def self.configuration
Rails::Configuration.new
end
module Generators
def self.clear_aliases!
@aliases = nil
end
def self.clear_options!
@@options = nil
end
end
end
class ConfigurationMock < Rails::Configuration
attr_reader :environment_path
def initialize(envpath)
super()
@environment_path = envpath
end
end
class Initializer_after_initialize_with_blocks_environment_Test < Test::Unit::TestCase
def setup
config = ConfigurationMock.new("")
config.after_initialize do
$test_after_initialize_block1 = "success"
end
config.after_initialize do
$test_after_initialize_block2 = "congratulations"
end
assert_nil $test_after_initialize_block1
assert_nil $test_after_initialize_block2
config.expects(:gems_dependencies_loaded).returns(true)
Rails::Initializer.run(:after_initialize, config)
end
def teardown
$test_after_initialize_block1 = nil
$test_after_initialize_block2 = nil
end
def test_should_have_called_the_first_after_initialize_block
assert_equal "success", $test_after_initialize_block1
end
def test_should_have_called_the_second_after_initialize_block
assert_equal "congratulations", $test_after_initialize_block2
end
end
class Initializer_after_initialize_with_no_block_environment_Test < Test::Unit::TestCase
def setup
config = ConfigurationMock.new("")
config.after_initialize do
$test_after_initialize_block1 = "success"
end
config.after_initialize # don't pass a block, this is what we're testing!
config.after_initialize do
$test_after_initialize_block2 = "congratulations"
end
assert_nil $test_after_initialize_block1
config.expects(:gems_dependencies_loaded).returns(true)
Rails::Initializer.run(:after_initialize, config)
end
def teardown
$test_after_initialize_block1 = nil
$test_after_initialize_block2 = nil
end
def test_should_have_called_the_first_after_initialize_block
assert_equal "success", $test_after_initialize_block1, "should still get set"
end
def test_should_have_called_the_second_after_initialize_block
assert_equal "congratulations", $test_after_initialize_block2
end
end
class ConfigurationFrameworkPathsTests < Test::Unit::TestCase
def setup
@config = Rails::Configuration.new
@config.frameworks.clear
@initializer = Rails::Initializer.default
@initializer.config = @config
File.stubs(:directory?).returns(true)
Rails::Initializer.run(:set_root_path, @config)
end
def test_minimal
expected = %w(railties railties/lib activesupport/lib)
assert_equal expected.map {|e| "#{@config.framework_root_path}/#{e}"}, @config.framework_paths
end
def test_actioncontroller_or_actionview_add_actionpack
@config.frameworks << :action_controller
assert_framework_path "actionpack/lib"
@config.frameworks = [:action_view]
assert_framework_path 'actionpack/lib'
end
def test_paths_for_ar_ares_and_mailer
[:active_record, :action_mailer, :active_resource, :action_web_service].each do |framework|
@config.frameworks = [framework]
assert_framework_path "#{framework.to_s.gsub('_', '')}/lib"
end
end
def test_action_mailer_load_paths_set_only_if_action_mailer_in_use
@config.frameworks = [:action_controller]
@initializer.config = @config
@initializer.run :require_frameworks
assert_nothing_raised NameError do
@initializer.run :load_view_paths
end
end
def test_action_controller_load_paths_set_only_if_action_controller_in_use
@config.frameworks = []
@initializer.run :require_frameworks
assert_nothing_raised NameError do
@initializer.run :load_view_paths
end
end
protected
def assert_framework_path(path)
assert @config.framework_paths.include?("#{@config.framework_root_path}/#{path}"),
"<#{path.inspect}> not found among <#{@config.framework_paths.inspect}>"
end
end
require 'plugin_test_helper'
class InitializerPluginLoadingTests < Test::Unit::TestCase
def setup
@configuration = Rails::Configuration.new
@configuration.frameworks -= [:action_mailer]
@configuration.plugin_paths << plugin_fixture_root_path
@initializer = Rails::Initializer.default
@initializer.config = @configuration
@valid_plugin_path = plugin_fixture_path('default/stubby')
@empty_plugin_path = plugin_fixture_path('default/empty')
end
def test_no_plugins_are_loaded_if_the_configuration_has_an_empty_plugin_list
only_load_the_following_plugins! []
@initializer.run :load_plugins
assert_equal [], @configuration.loaded_plugins
end
def test_only_the_specified_plugins_are_located_in_the_order_listed
plugin_names = [:plugin_with_no_lib_dir, :acts_as_chunky_bacon]
only_load_the_following_plugins! plugin_names
load_plugins!
assert_plugins plugin_names, @configuration.loaded_plugins
end
private
def load_plugins!
@initializer.run(:add_plugin_load_paths)
@initializer.run(:load_plugins)
end
end
class InitializerGeneratorsTests < Test::Unit::TestCase
def setup
@configuration = Rails::Configuration.new
@initializer = Rails::Initializer.default
@initializer.config = @configuration
end
def test_generators_default_values
assert_equal(true, @configuration.generators.colorize_logging)
assert_equal({}, @configuration.generators.aliases)
assert_equal({}, @configuration.generators.options)
end
def test_generators_set_rails_options
@configuration.generators.orm = :datamapper
@configuration.generators.test_framework = :rspec
expected = { :rails => { :orm => :datamapper, :test_framework => :rspec } }
assert_equal expected, @configuration.generators.options
end
def test_generators_set_rails_aliases
@configuration.generators.aliases = { :rails => { :test_framework => "-w" } }
expected = { :rails => { :test_framework => "-w" } }
assert_equal expected, @configuration.generators.aliases
end
def test_generators_aliases_and_options_on_initialization
@configuration.generators.rails :aliases => { :test_framework => "-w" }
@configuration.generators.orm :datamapper
@configuration.generators.test_framework :rspec
@initializer.run(:initialize_generators)
assert_equal :rspec, Rails::Generators.options[:rails][:test_framework]
assert_equal "-w", Rails::Generators.aliases[:rails][:test_framework]
end
def test_generators_no_color_on_initialization
@configuration.generators.colorize_logging = false
@initializer.run(:initialize_generators)
assert_equal Thor::Base.shell, Thor::Shell::Basic
end
def test_generators_with_hashes_for_options_and_aliases
@configuration.generators do |g|
g.orm :datamapper, :migration => false
g.plugin :aliases => { :generator => "-g" },
:generator => true
end
expected = {
:rails => { :orm => :datamapper },
:plugin => { :generator => true },
:datamapper => { :migration => false }
}
assert_equal expected, @configuration.generators.options
assert_equal({ :plugin => { :generator => "-g" } }, @configuration.generators.aliases)
end
def test_generators_with_hashes_are_deep_merged
@configuration.generators do |g|
g.orm :datamapper, :migration => false
g.plugin :aliases => { :generator => "-g" },
:generator => true
end
@initializer.run(:initialize_generators)
assert Rails::Generators.aliases.size >= 1
assert Rails::Generators.options.size >= 1
end
protected
def teardown
Rails::Generators.clear_aliases!
Rails::Generators.clear_options!
end
end
class InitializerSetupI18nTests < Test::Unit::TestCase
def test_no_config_locales_dir_present_should_return_empty_load_path
File.stubs(:exist?).returns(false)
assert_equal [], Rails::Configuration.new.i18n.load_path
end
def test_config_locales_dir_present_should_be_added_to_load_path
File.stubs(:exist?).returns(true)
Dir.stubs(:[]).returns([ "my/test/locale.yml" ])
assert_equal [ "my/test/locale.yml" ], Rails::Configuration.new.i18n.load_path
end
def test_config_defaults_should_be_added_with_config_settings
File.stubs(:exist?).returns(true)
Dir.stubs(:[]).returns([ "my/test/locale.yml" ])
config = Rails::Configuration.new
config.i18n.load_path << "my/other/locale.yml"
assert_equal [ "my/test/locale.yml", "my/other/locale.yml" ], config.i18n.load_path
end
end
class InitializerDatabaseMiddlewareTest < Test::Unit::TestCase
def setup
@config = Rails::Configuration.new
@config.frameworks = [:active_record, :action_controller, :action_view]
end
def test_initialize_database_middleware_doesnt_perform_anything_when_active_record_not_in_frameworks
@config.frameworks.clear
@config.expects(:middleware).never
Rails::Initializer.run(:initialize_database_middleware, @config)
end
def test_database_middleware_initializes_when_session_store_is_active_record
store = ActionController::Base.session_store
ActionController::Base.session_store = ActiveRecord::SessionStore
@config.middleware.expects(:insert_before).with(:"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement)
@config.middleware.expects(:insert_before).with(:"ActiveRecord::SessionStore", ActiveRecord::QueryCache)
Rails::Initializer.run(:initialize_database_middleware, @config)
ensure
ActionController::Base.session_store = store
end
def test_database_middleware_doesnt_initialize_when_session_store_is_not_active_record
store = ActionController::Base.session_store
ActionController::Base.session_store = ActionDispatch::Session::CookieStore
# Define the class, so we don't have to actually make it load
eval("class ActiveRecord::ConnectionAdapters::ConnectionManagement; end")
@config.middleware.expects(:use).with(ActiveRecord::ConnectionAdapters::ConnectionManagement)
@config.middleware.expects(:use).with(ActiveRecord::QueryCache)
Rails::Initializer.run(:initialize_database_middleware, @config)
ensure
ActionController::Base.session_store = store
end
def test_ensure_database_middleware_doesnt_use_action_controller_on_initializing
@config.frameworks -= [:action_controller]
store = ActionController::Base.session_store
ActionController::Base.session_store = ActiveRecord::SessionStore
@config.middleware.expects(:use).with(ActiveRecord::ConnectionAdapters::ConnectionManagement)
@config.middleware.expects(:use).with(ActiveRecord::QueryCache)
Rails::Initializer.run(:initialize_database_middleware, @config)
ensure
ActionController::Base.session_store = store
@config.frameworks += [:action_controller]
end
end
class InitializerViewPathsTest < Test::Unit::TestCase
def setup
@config = Rails::Configuration.new
@config.frameworks = [:action_view, :action_controller, :action_mailer]
ActionController::Base.stubs(:view_paths).returns(stub)
ActionMailer::Base.stubs(:view_paths).returns(stub)
end
def test_load_view_paths_doesnt_perform_anything_when_action_view_not_in_frameworks
@config.frameworks -= [:action_view]
ActionController::Base.view_paths.expects(:load!).never
ActionMailer::Base.view_paths.expects(:load!).never
Rails::Initializer.run(:load_view_paths, @config)
end
end
class RailsRootTest < Test::Unit::TestCase
def test_rails_dot_root_equals_rails_root
assert_equal RAILS_ROOT, Rails.root.to_s

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

@ -31,6 +31,10 @@ module TestHelpers
tmp_path(*%w[app] + args)
end
def framework_path
RAILS_FRAMEWORK_ROOT
end
def rails_root
app_path
end

165
railties/test/new_initializer_test.rb
View File

@ -1,165 +0,0 @@
require 'abstract_unit'
require 'active_support/ruby/shim'
require 'rails/initializer'
class InitializerRunnerTest < ActiveSupport::TestCase
def setup
@runner = Rails::Initializer::Runner.new
end
test "A new runner can be created" do
assert @runner
end
test "The initializers actually get run when the runner is run" do
state = nil
@runner.add :foo do
run { state = true }
end
@runner.run
assert state
end
test "By default, initializers get run in the order that they are added" do
state = []
@runner.add :first do
run { state << :first }
end
@runner.add :second do
run { state << :second }
end
@runner.run
assert_equal [:first, :second], state
end
test "Raises an exception if :before or :after are specified, but don't exist" do
assert_raise(Rails::Initializer::Error) do
@runner.add(:fail, :before => :whale) { 1 }
end
assert_raise(Rails::Initializer::Error) do
@runner.add(:fail, :after => :whale) { 1 }
end
end
test "When adding an initializer, specifying :after allows you to move an initializer after another" do
state = []
@runner.add :first do
run { state << :first }
end
@runner.add :second do
run { state << :second }
end
@runner.add :third, :after => :first do
run { state << :third }
end
@runner.run
assert_equal [:first, :third, :second], state
end
test "An initializer can be deleted" do
state = []
@runner.add :first do
run { state << :first }
end
@runner.add :second do
run { state << :second }
end
@runner.delete(:second)
@runner.run
assert_equal [:first], state
end
test "A runner can be initialized with an existing runner, which it copies" do
state = []
@runner.add :first do
run { state << :first }
end
@runner.add :second do
run { state << :second }
end
Rails::Initializer::Runner.new(@runner).run
assert_equal [:first, :second], state
end
test "A child runner can be still be modified without modifying the parent" do
state = []
@runner.add :first do
run { state << :first }
end
@runner.add :second do
run { state << :second }
end
new_runner = Rails::Initializer::Runner.new(@runner)
new_runner.add :trois do
run { state << :trois }
end
new_runner.delete(:second)
new_runner.run
assert_equal [:first, :trois], state
state.clear
@runner.run
assert_equal [:first, :second], state
end
test "A child runner that is modified does not modify any other children of the same parent" do
state = []
@runner.add :first do
run { state << :first }
end
@runner.add :second do
run { state << :second }
end
child_one = Rails::Initializer::Runner.new(@runner)
child_two = Rails::Initializer::Runner.new(@runner)
child_one.delete(:second)
child_two.run
assert_equal [:first, :second], state
end
test "It does not run the initializer block immediately" do
state = []
@runner.add :first do
state << :first
end
assert_equal [], state
end
test "It runs the block when the runner is run" do
state = []
@runner.add :first do
state << :first
end
@runner.run
assert_equal [:first], state
end
end

17
railties/test/plugin_loader_test.rb
View File

@ -5,10 +5,13 @@ $:.unshift File.dirname(__FILE__) + "/../../actionmailer/lib"
require 'action_controller'
require 'action_mailer'
# Mocks out the configuration
module Rails
def self.configuration
Rails::Configuration.new
# TODO: Rewrite all these tests
class FakeInitializerSlashApplication
attr_reader :config
alias configuration config
def initialize
@config = Rails::Configuration.new
end
end
@ -18,10 +21,10 @@ class TestPluginLoader < Test::Unit::TestCase
def setup
reset_load_path!
@configuration = Rails::Configuration.new
@initializer = FakeInitializerSlashApplication.new
@configuration = @initializer.config
Rails.application = @initializer
@configuration.plugin_paths << plugin_fixture_root_path
@initializer = Rails::Initializer.default
@initializer.config = @configuration
@valid_plugin_path = plugin_fixture_path('default/stubby')
@empty_plugin_path = plugin_fixture_path('default/empty')

16
railties/test/plugin_locator_test.rb
View File

@ -1,5 +1,15 @@
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
@ -23,12 +33,12 @@ end
class PluginFileSystemLocatorTest < Test::Unit::TestCase
def setup
@configuration = Rails::Configuration.new
@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
@initializer = Rails::Initializer.default
@initializer.config = @configuration
@locator = Rails::Plugin::FileSystemLocator.new(@initializer)
@valid_plugin_path = plugin_fixture_path('default/stubby')
@empty_plugin_path = plugin_fixture_path('default/empty')

15
railties/test/plugin_test.rb
View File

@ -1,9 +1,20 @@
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 = Rails::Initializer.default
@initializer.config = Rails::Configuration.new
@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')