The Initializer is responsible for processing the Rails configuration, such as setting the $LOAD_PATH, requiring the right frameworks, initializing logging, and more. It can be run either as a single command that'll just use the default configuration, like this:
Rails::Initializer.run
But normally it's more interesting to pass in a custom configuration through the block running:
Rails::Initializer.run do |config| config.frameworks -= [ :action_mailer ] end
This will use the default configuration options from Rails::Configuration, but allow for overwriting on select areas.
Create a new Initializer instance that references the given Configuration instance.
# File lib/initializer.rb, line 125 def initialize(configuration) @configuration = configuration @loaded_plugins = [] end
Runs the initializer. By default, this will invoke the process method, which simply executes all of the initialization routines. Alternately, you can specify explicitly which initialization routine you want:
Rails::Initializer.run(:set_load_path)
This is useful if you only want the load path initialized, without incurring the overhead of completely loading the entire environment.
# File lib/initializer.rb, line 116 def self.run(command = :process, configuration = Configuration.new) yield configuration if block_given? initializer = new configuration initializer.send(command) initializer end
# File lib/initializer.rb, line 304 def add_gem_load_paths return unless CAN_HAS_GEMS Rails::GemDependency.add_frozen_gem_path unless @configuration.gems.empty? require "rubygems" @configuration.gems.each { |gem| gem.add_load_paths } end 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).
# File lib/initializer.rb, line 300 def add_plugin_load_paths plugin_loader.add_plugin_load_paths end
Add the load paths used by support functions such as the info controller
# File lib/initializer.rb, line 295 def add_support_load_paths end
Fires the user-supplied after_initialize block (Configuration#after_initialize)
# File lib/initializer.rb, line 623 def after_initialize if gems_dependencies_loaded configuration.after_initialize_blocks.each do |block| block.call end end end
# File lib/initializer.rb, line 319 def check_for_unbuilt_gems unbuilt_gems = @configuration.gems.select(&:frozen?).reject(&:built?) if unbuilt_gems.size > 0 # don't print if the gems:build rake tasks are being run unless $gems_build_rake_task abort The following gems have native components that need to be built #{unbuilt_gems.map { |gem| "#{gem.name} #{gem.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 end end
# File lib/initializer.rb, line 338 def check_gem_dependencies unless CAN_HAS_GEMS @gems_dependencies_loaded = true return end unloaded_gems = @configuration.gems.reject { |g| g.loaded? } if unloaded_gems.size > 0 @gems_dependencies_loaded = false # don't print if the gems rake tasks are being run unless $gems_rake_task abort Missing these required gems: #{unloaded_gems.map { |gem| "#{gem.name} #{gem.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 else @gems_dependencies_loaded = true end end
Check for valid Ruby version This is done in an external file, so we can use it from the `rails` program as well without duplication.
# File lib/initializer.rb, line 215 def check_ruby_version require 'ruby_version_check' end
# File lib/initializer.rb, line 646 def disable_dependency_loading if configuration.cache_classes && !configuration.dependency_loading ActiveSupport::Dependencies.unhook! end end
# File lib/initializer.rb, line 467 def initialize_cache 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(:"ActionController::Failsafe", RAILS_CACHE.middleware) end end end
This initialization routine does nothing unless :active_record 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.
# File lib/initializer.rb, line 447 def initialize_database if configuration.frameworks.include?(:active_record) ActiveRecord::Base.configurations = configuration.database_configuration ActiveRecord::Base.establish_connection end end
# File lib/initializer.rb, line 454 def initialize_database_middleware if configuration.frameworks.include?(:active_record) if configuration.frameworks.include?(:action_controller) && 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
Sets the dependency loading mechanism based on the value of Configuration#cache_classes.
# File lib/initializer.rb, line 554 def initialize_dependency_mechanism ActiveSupport::Dependencies.mechanism = configuration.cache_classes ? :require : :load end
For Ruby 1.8, this initialization sets $KCODE to 'u' to enable the multibyte safe operations. Plugin authors supporting other encodings should override this behaviour and set the relevant default_charset on ActionController::Base.
For Ruby 1.9, this does nothing. Specify the default encoding in the Ruby shebang line if you don't want UTF-8.
# File lib/initializer.rb, line 439 def initialize_encoding $KCODE='u' if RUBY_VERSION < '1.9' end
# File lib/initializer.rb, line 478 def initialize_framework_caches if configuration.frameworks.include?(:action_controller) ActionController::Base.cache_store ||= RAILS_CACHE end 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.
# File lib/initializer.rb, line 520 def initialize_framework_logging 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
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.
# File lib/initializer.rb, line 609 def initialize_framework_settings 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.
# File lib/initializer.rb, line 533 def initialize_framework_views 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
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.
# File lib/initializer.rb, line 587 def initialize_i18n configuration.i18n.each do |setting, value| if setting == :load_path I18n.load_path += value else I18n.send("#{setting}=", value) end end end
If the RAILS_DEFAULT_LOGGER constant is already set, this initialization routine does nothing. If the constant is not set, and Configuration#logger is not nil, this also does nothing. Otherwise, a new logger instance is created at Configuration#log_path, with a default log level of Configuration#log_level.
If the log could not be created, the log will be set to output to STDERR, with a log level of WARN.
# File lib/initializer.rb, line 492 def initialize_logger # if the environment has explicitly defined a logger, use it return 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 configuration.environment == "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 silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger } end
# File lib/initializer.rb, line 597 def initialize_metal Rails::Rack::Metal.requested_metals = configuration.metals Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths configuration.middleware.insert_before( :"ActionController::ParamsParser", Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?) end
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).
# File lib/initializer.rb, line 544 def initialize_routing return 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
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.
# File lib/initializer.rb, line 566 def initialize_time_zone 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
Loads support for "whiny nil" (noisy warnings when methods are invoked on nil values) if Configuration#whiny_nils is true.
# File lib/initializer.rb, line 560 def initialize_whiny_nils require('active_support/whiny_nil') if configuration.whiny_nils end
If Rails is vendored and RubyGems is available, install stub GemSpecs for Rails, Active Support, Active Record, Action Pack, Action Mailer, and Active Resource. This allows Gem plugins to depend on Rails even when the Gem version of Rails shouldn't be loaded.
# File lib/initializer.rb, line 223 def install_gem_spec_stubs return unless CAN_HAS_GEMS unless Rails.respond_to?(:vendor_rails?) abort %{Your config/boot.rb is outdated: Run "rake rails:update".} end if Rails.vendor_rails? begin; require "rubygems"; rescue LoadError; return; end stubs = %(rails activesupport activerecord actionpack actionmailer activeresource) stubs.reject! { |s| Gem.loaded_specs.key?(s) } stubs.each do |stub| Gem.loaded_specs[stub] = Gem::Specification.new do |s| s.name = stub s.version = Rails::VERSION::STRING s.loaded_from = "" end end end end
Eager load application classes
# File lib/initializer.rb, line 420 def load_application_classes return if $rails_rake_task && configuration.dependency_loading 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
# File lib/initializer.rb, line 631 def load_application_initializers if gems_dependencies_loaded Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer| load(initializer) end end end
Loads the environment specified by Configuration#environment_path, which is typically one of development, test, or production.
# File lib/initializer.rb, line 390 def load_environment silence_warnings do return if @environment_loaded @environment_loaded = true config = configuration constants = self.class.constants eval(IO.read(configuration.environment_path), binding, configuration.environment_path) (self.class.constants - constants).each do |const| Object.const_set(const, self.class.const_get(const)) end end end
# File lib/initializer.rb, line 313 def load_gems unless $gems_rake_task @configuration.gems.each { |gem| gem.load } end end
# File lib/initializer.rb, line 406 def load_observers if gems_dependencies_loaded && configuration.frameworks.include?(:active_record) ActiveRecord::Base.instantiate_observers end end
Loads all plugins in config.plugin_paths. plugin_paths defaults to vendor/plugins 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 plugin_paths is initialized:
its lib directory, if present, is added to the load path (immediately after the applications lib directory)
init.rb 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
# File lib/initializer.rb, line 380 def load_plugins plugin_loader.load_plugins end
# File lib/initializer.rb, line 412 def load_view_paths if configuration.frameworks.include?(:action_view) ActionController::Base.view_paths.load! if configuration.frameworks.include?(:action_controller) ActionMailer::Base.view_paths.load! if configuration.frameworks.include?(:action_mailer) end end
# File lib/initializer.rb, line 384 def plugin_loader @plugin_loader ||= configuration.plugin_loader.new(self) end
Preload all frameworks specified by the Configuration#frameworks. Used by Passenger to ensure everything's loaded before forking and to avoid autoload race conditions in JRuby.
# File lib/initializer.rb, line 284 def preload_frameworks if configuration.preload_frameworks configuration.frameworks.each do |framework| # String#classify and #constantize aren't available yet. toplevel = Object.const_get(framework.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }) toplevel.load_all! if toplevel.respond_to?(:load_all!) end end end
# File lib/initializer.rb, line 639 def prepare_dispatcher return unless configuration.frameworks.include?(:action_controller) require 'dispatcher' unless defined?(::Dispatcher) Dispatcher.define_dispatcher_callbacks(configuration.cache_classes) Dispatcher.run_prepare_callbacks end
Sequentially step through all of the available initialization routines, in order (view execution order in source).
# File lib/initializer.rb, line 132 def process Rails.configuration = configuration check_ruby_version install_gem_spec_stubs set_load_path add_gem_load_paths require_frameworks set_autoload_paths add_plugin_load_paths load_environment preload_frameworks initialize_encoding initialize_database initialize_cache initialize_framework_caches initialize_logger initialize_framework_logging initialize_dependency_mechanism initialize_whiny_nils initialize_time_zone initialize_i18n initialize_framework_settings initialize_framework_views initialize_metal add_support_load_paths check_for_unbuilt_gems load_gems load_plugins # pick up any gems that plugins depend on add_gem_load_paths load_gems check_gem_dependencies # 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 load_application_initializers # the framework is now fully initialized after_initialize # Setup database middleware after initializers have run initialize_database_middleware # Prepare dispatcher callbacks and run 'prepare' callbacks prepare_dispatcher # Routing must be initialized after plugins to allow the former to extend the routes initialize_routing # Observers are loaded after plugins in case Observers or observed models are modified by plugins. load_observers # Load view path cache load_view_paths # Load application classes load_application_classes # Disable dependency loading during request cycle disable_dependency_loading # Flag initialized Rails.initialized = true end
Requires all frameworks specified by the Configuration#frameworks list. By default, all frameworks (Active Record, Active Support, Action Pack, Action Mailer, and Active Resource) are loaded.
# File lib/initializer.rb, line 274 def require_frameworks configuration.frameworks.each { |framework| require(framework.to_s) } rescue LoadError => e # Re-raise as RuntimeError because Mongrel would swallow LoadError. raise e.to_s end
Set the paths from which Rails will automatically load source files, and the load_once paths.
# File lib/initializer.rb, line 255 def set_autoload_paths ActiveSupport::Dependencies.autoload_paths = configuration.autoload_paths.uniq ActiveSupport::Dependencies.autoload_once_paths = configuration.autoload_once_paths.uniq extra = ActiveSupport::Dependencies.autoload_once_paths - ActiveSupport::Dependencies.autoload_paths unless extra.empty? abort autoload_once_paths must be a subset of the autoload_paths. Extra items in autoload_once_paths: #{extra * ','} end # Freeze the arrays so future modifications will fail rather than do nothing mysteriously configuration.autoload_once_paths.freeze end
Set the $LOAD_PATH based on the value of Configuration#autoload_paths. Duplicates are removed.
# File lib/initializer.rb, line 247 def set_load_path load_paths = configuration.autoload_paths + configuration.framework_paths load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) } $LOAD_PATH.uniq! end
Generated with the Darkfish Rdoc Generator 2.