Even more initializers ported over

railties/lib/rails/application.rb

@@ -116,7 +116,7 @@ def new
         @environment_loaded = true
         constants = self.class.constants
 
-        eval(IO.read(configuration.environment_path), binding, configuration.environment_path)
+        eval(IO.read(config.environment_path), binding, config.environment_path)
 
         (self.class.constants - constants).each do |const|
           Object.const_set(const, self.class.const_get(const))
@@ -145,5 +145,137 @@ def new
         end
       end
     end
+
+    # This initialization routine does nothing unless <tt>:active_record</tt>
+    # is one of the frameworks to load (Configuration#frameworks). If it is,
+    # this sets the database configuration from Configuration#database_configuration
+    # and then establishes the connection.
+    initializer :initialize_database do
+      if config.frameworks.include?(:active_record)
+        ActiveRecord::Base.configurations = config.database_configuration
+        ActiveRecord::Base.establish_connection
+      end
+    end
+
+    # Include middleware to serve up static assets
+    initializer :initialize_static_server do
+      if config.frameworks.include?(:action_controller) && config.serve_static_assets
+        config.middleware.use(ActionDispatch::Static, Rails.public_path)
+      end
+    end
+
+    initializer :initialize_middleware_stack do
+      if config.frameworks.include?(:action_controller)
+        config.middleware.use(::Rack::Lock) unless ActionController::Base.allow_concurrency
+        config.middleware.use(ActionDispatch::ShowExceptions, ActionController::Base.consider_all_requests_local)
+        config.middleware.use(ActionDispatch::Callbacks, ActionController::Dispatcher.prepare_each_request)
+        config.middleware.use(lambda { ActionController::Base.session_store }, lambda { ActionController::Base.session_options })
+        config.middleware.use(ActionDispatch::ParamsParser)
+        config.middleware.use(::Rack::MethodOverride)
+        config.middleware.use(::Rack::Head)
+        config.middleware.use(ActionDispatch::StringCoercion)
+      end
+    end
+
+    initializer :initialize_cache do
+      unless defined?(RAILS_CACHE)
+        silence_warnings { Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(config.cache_store) }
+
+        if RAILS_CACHE.respond_to?(:middleware)
+          # Insert middleware to setup and teardown local cache for each request
+          config.middleware.insert_after(:"Rack::Lock", RAILS_CACHE.middleware)
+        end
+      end
+    end
+
+    initializer :initialize_framework_caches do
+      if config.frameworks.include?(:action_controller)
+        ActionController::Base.cache_store ||= RAILS_CACHE
+      end
+    end
+
+    initializer :initialize_logger do
+      # if the environment has explicitly defined a logger, use it
+      next if Rails.logger
+
+      unless logger = config.logger
+        begin
+          logger = ActiveSupport::BufferedLogger.new(config.log_path)
+          logger.level = ActiveSupport::BufferedLogger.const_get(config.log_level.to_s.upcase)
+          if RAILS_ENV == "production"
+            logger.auto_flushing = false
+          end
+        rescue StandardError => e
+          logger = ActiveSupport::BufferedLogger.new(STDERR)
+          logger.level = ActiveSupport::BufferedLogger::WARN
+          logger.warn(
+            "Rails Error: Unable to access log file. Please ensure that #{config.log_path} exists and is chmod 0666. " +
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
+          )
+        end
+      end
+
+      # TODO: Why are we silencing warning here?
+      silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }
+    end
+
+    # Sets the logger for Active Record, Action Controller, and Action Mailer
+    # (but only for those frameworks that are to be loaded). If the framework's
+    # logger is already set, it is not changed, otherwise it is set to use
+    # RAILS_DEFAULT_LOGGER.
+    initializer :initialize_framework_logging do
+      for framework in ([ :active_record, :action_controller, :action_mailer ] & config.frameworks)
+        framework.to_s.camelize.constantize.const_get("Base").logger ||= Rails.logger
+      end
+
+      ActiveSupport::Dependencies.logger ||= Rails.logger
+      Rails.cache.logger ||= Rails.logger
+    end
+
+    # Sets the dependency loading mechanism based on the value of
+    # Configuration#cache_classes.
+    initializer :initialize_dependency_mechanism do
+      # TODO: Remove files from the $" and always use require
+      ActiveSupport::Dependencies.mechanism = config.cache_classes ? :require : :load
+    end
+
+    # Loads support for "whiny nil" (noisy warnings when methods are invoked
+    # on +nil+ values) if Configuration#whiny_nils is true.
+    initializer :initialize_whiny_nils do
+      require('active_support/whiny_nil') if config.whiny_nils
+    end
+
+    # Sets the default value for Time.zone, and turns on ActiveRecord::Base#time_zone_aware_attributes.
+    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
+    initializer :initialize_time_zone do
+      if config.time_zone
+        zone_default = Time.__send__(:get_zone, config.time_zone)
+
+        unless zone_default
+          raise \
+            'Value assigned to config.time_zone not recognized.' +
+            'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
+        end
+
+        Time.zone_default = zone_default
+
+        if config.frameworks.include?(:active_record)
+          ActiveRecord::Base.time_zone_aware_attributes = true
+          ActiveRecord::Base.default_timezone = :utc
+        end
+      end
+    end
+
+    # Set the i18n configuration from config.i18n but special-case for the load_path which should be
+    # appended to what's already set instead of overwritten.
+    initializer :initialize_i18n do
+      config.i18n.each do |setting, value|
+        if setting == :load_path
+          I18n.load_path += value
+        else
+          I18n.send("#{setting}=", value)
+        end
+      end
+    end
   end
 end

railties/lib/rails/initializer.rb

@@ -107,148 +107,15 @@ def self.run(initializer = nil, config = nil)
         default.run(initializer)
       else
         Rails.application = Class.new(Application)
+        yield Rails.application.config if block_given?
         # Trigger the initializer
         Rails.application.new
-        yield Rails.application.config if block_given?
         default.config = Rails.application.config
         default.run
       end
     end
   end
 
-  # This initialization routine does nothing unless <tt>:active_record</tt>
-  # is one of the frameworks to load (Configuration#frameworks). If it is,
-  # this sets the database configuration from Configuration#database_configuration
-  # and then establishes the connection.
-  Initializer.default.add :initialize_database do
-    if configuration.frameworks.include?(:active_record)
-      ActiveRecord::Base.configurations = configuration.database_configuration
-      ActiveRecord::Base.establish_connection
-    end
-  end
-
-  # Include middleware to serve up static assets
-  Initializer.default.add :initialize_static_server do
-    if configuration.frameworks.include?(:action_controller) && configuration.serve_static_assets
-      configuration.middleware.use(ActionDispatch::Static, Rails.public_path)
-    end
-  end
-
-  Initializer.default.add :initialize_middleware_stack do
-    if configuration.frameworks.include?(:action_controller)
-      configuration.middleware.use(::Rack::Lock) unless ActionController::Base.allow_concurrency
-      configuration.middleware.use(ActionDispatch::ShowExceptions, ActionController::Base.consider_all_requests_local)
-      configuration.middleware.use(ActionDispatch::Callbacks, ActionController::Dispatcher.prepare_each_request)
-      configuration.middleware.use(lambda { ActionController::Base.session_store }, lambda { ActionController::Base.session_options })
-      configuration.middleware.use(ActionDispatch::ParamsParser)
-      configuration.middleware.use(::Rack::MethodOverride)
-      configuration.middleware.use(::Rack::Head)
-      configuration.middleware.use(ActionDispatch::StringCoercion)
-    end
-  end
-
-  Initializer.default.add :initialize_cache do
-    unless defined?(RAILS_CACHE)
-      silence_warnings { Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(configuration.cache_store) }
-
-      if RAILS_CACHE.respond_to?(:middleware)
-        # Insert middleware to setup and teardown local cache for each request
-        configuration.middleware.insert_after(:"Rack::Lock", RAILS_CACHE.middleware)
-      end
-    end
-  end
-
-  Initializer.default.add :initialize_framework_caches do
-    if configuration.frameworks.include?(:action_controller)
-      ActionController::Base.cache_store ||= RAILS_CACHE
-    end
-  end
-
-  Initializer.default.add :initialize_logger do
-    # if the environment has explicitly defined a logger, use it
-    next if Rails.logger
-
-    unless logger = configuration.logger
-      begin
-        logger = ActiveSupport::BufferedLogger.new(configuration.log_path)
-        logger.level = ActiveSupport::BufferedLogger.const_get(configuration.log_level.to_s.upcase)
-        if RAILS_ENV == "production"
-          logger.auto_flushing = false
-        end
-      rescue StandardError => e
-        logger = ActiveSupport::BufferedLogger.new(STDERR)
-        logger.level = ActiveSupport::BufferedLogger::WARN
-        logger.warn(
-          "Rails Error: Unable to access log file. Please ensure that #{configuration.log_path} exists and is chmod 0666. " +
-          "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed."
-        )
-      end
-    end
-
-    # TODO: Why are we silencing warning here?
-    silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }
-  end
-
-  # Sets the logger for Active Record, Action Controller, and Action Mailer
-  # (but only for those frameworks that are to be loaded). If the framework's
-  # logger is already set, it is not changed, otherwise it is set to use
-  # RAILS_DEFAULT_LOGGER.
-  Initializer.default.add :initialize_framework_logging do
-    for framework in ([ :active_record, :action_controller, :action_mailer ] & configuration.frameworks)
-      framework.to_s.camelize.constantize.const_get("Base").logger ||= Rails.logger
-    end
-
-    ActiveSupport::Dependencies.logger ||= Rails.logger
-    Rails.cache.logger ||= Rails.logger
-  end
-
-  # Sets the dependency loading mechanism based on the value of
-  # Configuration#cache_classes.
-  Initializer.default.add :initialize_dependency_mechanism do
-    # TODO: Remove files from the $" and always use require
-    ActiveSupport::Dependencies.mechanism = configuration.cache_classes ? :require : :load
-  end
-
-  # Loads support for "whiny nil" (noisy warnings when methods are invoked
-  # on +nil+ values) if Configuration#whiny_nils is true.
-  Initializer.default.add :initialize_whiny_nils do
-    require('active_support/whiny_nil') if configuration.whiny_nils
-  end
-
-
-  # Sets the default value for Time.zone, and turns on ActiveRecord::Base#time_zone_aware_attributes.
-  # If assigned value cannot be matched to a TimeZone, an exception will be raised.
-  Initializer.default.add :initialize_time_zone do
-    if configuration.time_zone
-      zone_default = Time.__send__(:get_zone, configuration.time_zone)
-
-      unless zone_default
-        raise \
-          'Value assigned to config.time_zone not recognized.' +
-          'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
-      end
-
-      Time.zone_default = zone_default
-
-      if configuration.frameworks.include?(:active_record)
-        ActiveRecord::Base.time_zone_aware_attributes = true
-        ActiveRecord::Base.default_timezone = :utc
-      end
-    end
-  end
-
-  # Set the i18n configuration from config.i18n but special-case for the load_path which should be
-  # appended to what's already set instead of overwritten.
-  Initializer.default.add :initialize_i18n do
-    configuration.i18n.each do |setting, value|
-      if setting == :load_path
-        I18n.load_path += value
-      else
-        I18n.send("#{setting}=", value)
-      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.

railties/test/application/initializer_test.rb

@@ -55,6 +55,13 @@ module Zoo::ReptileHouse ; end
       assert Zoo
     end
 
+    test "setting another default locale" do
+      Rails::Initializer.run do |config|
+        config.i18n.default_locale = :de
+      end
+      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

railties/test/initializer_test.rb

@@ -286,13 +286,6 @@ def test_config_defaults_should_be_added_with_config_settings
 
     assert_equal [ "my/test/locale.yml", "my/other/locale.yml" ], config.i18n.load_path
   end
-
-  def test_setting_another_default_locale
-    config = Rails::Configuration.new
-    config.i18n.default_locale = :de
-    Rails::Initializer.run(:initialize_i18n, config)
-    assert_equal :de, I18n.default_locale
-  end
 end
 
 class InitializerDatabaseMiddlewareTest < Test::Unit::TestCase