Class: Rails::Initializer
Overview
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.
Instance Attribute Summary collapse
-
#configuration ⇒ Object
readonly
The Configuration instance used by this Initializer instance.
-
#gems_dependencies_loaded ⇒ Object
readonly
Whether or not all the gem dependencies have been met.
-
#loaded_plugins ⇒ Object
readonly
The set of loaded plugins.
Class Method Summary collapse
-
.run(command = :process, configuration = Configuration.new) {|configuration| ... } ⇒ Object
Runs the initializer.
Instance Method Summary collapse
- #add_gem_load_paths ⇒ Object
-
#add_plugin_load_paths ⇒ Object
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).
-
#add_support_load_paths ⇒ Object
Add the load paths used by support functions such as the info controller.
-
#after_initialize ⇒ Object
Fires the user-supplied after_initialize block (Configuration#after_initialize).
- #check_gem_dependencies ⇒ Object
-
#check_ruby_version ⇒ Object
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.
-
#initialize(configuration) ⇒ Initializer
constructor
Create a new Initializer instance that references the given Configuration instance.
- #initialize_cache ⇒ Object
-
#initialize_database ⇒ Object
This initialization routine does nothing unless
:active_record
is one of the frameworks to load (Configuration#frameworks). -
#initialize_dependency_mechanism ⇒ Object
Sets the dependency loading mechanism based on the value of Configuration#cache_classes.
-
#initialize_encoding ⇒ Object
For Ruby 1.8, this initialization sets $KCODE to ‘u’ to enable the multibyte safe operations.
- #initialize_framework_caches ⇒ Object
-
#initialize_framework_logging ⇒ Object
Sets the logger for Active Record, Action Controller, and Action Mailer (but only for those frameworks that are to be loaded).
-
#initialize_framework_settings ⇒ Object
Initializes framework-specific settings for each of the loaded frameworks (Configuration#frameworks).
-
#initialize_framework_views ⇒ Object
Sets ActionController::Base#view_paths and ActionMailer::Base#template_root (but only for those frameworks that are to be loaded).
-
#initialize_logger ⇒ Object
If the RAILS_DEFAULT_LOGGER constant is already set, this initialization routine does nothing.
-
#initialize_routing ⇒ Object
If Action Controller is not one of the loaded frameworks (Configuration#frameworks) this does nothing.
- #initialize_temporary_session_directory ⇒ Object
-
#initialize_time_zone ⇒ Object
Sets the default value for Time.zone, and turns on ActiveRecord::Base#time_zone_aware_attributes.
-
#initialize_whiny_nils ⇒ Object
Loads support for “whiny nil” (noisy warnings when methods are invoked on
nil
values) if Configuration#whiny_nils is true. -
#install_gem_spec_stubs ⇒ Object
If Rails is vendored and RubyGems is available, install stub GemSpecs for Rails, Active Support, Active Record, Action Pack, Action Mailer, and Active Resource.
- #load_application_initializers ⇒ Object
-
#load_environment ⇒ Object
Loads the environment specified by Configuration#environment_path, which is typically one of development, test, or production.
- #load_gems ⇒ Object
- #load_observers ⇒ Object
-
#load_plugins ⇒ Object
Loads all plugins in
config.plugin_paths
. - #plugin_loader ⇒ Object
- #prepare_dispatcher ⇒ Object
-
#process ⇒ Object
Sequentially step through all of the available initialization routines, in order (view execution order in source).
-
#require_frameworks ⇒ Object
Requires all frameworks specified by the Configuration#frameworks list.
-
#set_autoload_paths ⇒ Object
Set the paths from which Rails will automatically load source files, and the load_once paths.
-
#set_load_path ⇒ Object
Set the
$LOAD_PATH
based on the value of Configuration#load_paths.
Constructor Details
#initialize(configuration) ⇒ Initializer
Create a new Initializer instance that references the given Configuration instance.
103 104 105 106 |
# File 'lib/initializer.rb', line 103 def initialize(configuration) @configuration = configuration @loaded_plugins = [] end |
Instance Attribute Details
#configuration ⇒ Object (readonly)
The Configuration instance used by this Initializer instance.
78 79 80 |
# File 'lib/initializer.rb', line 78 def configuration @configuration end |
#gems_dependencies_loaded ⇒ Object (readonly)
Whether or not all the gem dependencies have been met
84 85 86 |
# File 'lib/initializer.rb', line 84 def gems_dependencies_loaded @gems_dependencies_loaded end |
#loaded_plugins ⇒ Object (readonly)
The set of loaded plugins.
81 82 83 |
# File 'lib/initializer.rb', line 81 def loaded_plugins @loaded_plugins end |
Class Method Details
.run(command = :process, configuration = Configuration.new) {|configuration| ... } ⇒ Object
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 incuring the overhead of completely loading the entire environment.
94 95 96 97 98 99 |
# File 'lib/initializer.rb', line 94 def self.run(command = :process, configuration = Configuration.new) yield configuration if block_given? initializer = new configuration initializer.send(command) initializer end |
Instance Method Details
#add_gem_load_paths ⇒ Object
242 243 244 245 246 247 |
# File 'lib/initializer.rb', line 242 def add_gem_load_paths unless @configuration.gems.empty? require "rubygems" @configuration.gems.each { |gem| gem.add_load_paths } end end |
#add_plugin_load_paths ⇒ Object
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).
238 239 240 |
# File 'lib/initializer.rb', line 238 def add_plugin_load_paths plugin_loader.add_plugin_load_paths end |
#add_support_load_paths ⇒ Object
Add the load paths used by support functions such as the info controller
233 234 |
# File 'lib/initializer.rb', line 233 def add_support_load_paths end |
#after_initialize ⇒ Object
Fires the user-supplied after_initialize block (Configuration#after_initialize)
473 474 475 476 477 478 479 |
# File 'lib/initializer.rb', line 473 def after_initialize if gems_dependencies_loaded configuration.after_initialize_blocks.each do |block| block.call end end end |
#check_gem_dependencies ⇒ Object
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 |
# File 'lib/initializer.rb', line 253 def check_gem_dependencies 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 $rails_gem_installer abort <<-end_error 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_error end else @gems_dependencies_loaded = true end end |
#check_ruby_version ⇒ Object
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.
168 169 170 |
# File 'lib/initializer.rb', line 168 def check_ruby_version require 'ruby_version_check' end |
#initialize_cache ⇒ Object
345 346 347 348 349 |
# File 'lib/initializer.rb', line 345 def initialize_cache unless defined?(RAILS_CACHE) silence_warnings { Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(configuration.cache_store) } end end |
#initialize_database ⇒ Object
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.
338 339 340 341 342 343 |
# File 'lib/initializer.rb', line 338 def initialize_database if configuration.frameworks.include?(:active_record) ActiveRecord::Base.configurations = configuration.database_configuration ActiveRecord::Base.establish_connection end end |
#initialize_dependency_mechanism ⇒ Object
Sets the dependency loading mechanism based on the value of Configuration#cache_classes.
423 424 425 |
# File 'lib/initializer.rb', line 423 def initialize_dependency_mechanism ActiveSupport::Dependencies.mechanism = configuration.cache_classes ? :require : :load end |
#initialize_encoding ⇒ Object
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.
330 331 332 |
# File 'lib/initializer.rb', line 330 def initialize_encoding $KCODE='u' if RUBY_VERSION < '1.9' end |
#initialize_framework_caches ⇒ Object
351 352 353 354 355 |
# File 'lib/initializer.rb', line 351 def initialize_framework_caches if configuration.frameworks.include?(:action_controller) ActionController::Base.cache_store ||= RAILS_CACHE end end |
#initialize_framework_logging ⇒ Object
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.
394 395 396 397 398 399 400 |
# File 'lib/initializer.rb', line 394 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_DEFAULT_LOGGER end RAILS_CACHE.logger ||= RAILS_DEFAULT_LOGGER end |
#initialize_framework_settings ⇒ Object
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.
459 460 461 462 463 464 465 466 467 468 469 470 |
# File 'lib/initializer.rb', line 459 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 |
#initialize_framework_views ⇒ Object
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.
406 407 408 409 |
# File 'lib/initializer.rb', line 406 def initialize_framework_views ActionMailer::Base.template_root ||= configuration.view_path if configuration.frameworks.include?(:action_mailer) ActionController::Base.view_paths = [configuration.view_path] if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.empty? end |
#initialize_logger ⇒ Object
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
.
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 |
# File 'lib/initializer.rb', line 365 def initialize_logger # if the environment has explicitly defined a logger, use it return if defined?(RAILS_DEFAULT_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 logger.set_non_blocking_io end rescue StandardError => e logger = ActiveSupport::BufferedLogger.new(STDERR) logger.level = ActiveSupport::BufferedLogger::WARN logger.warn( "Enhanced 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 |
#initialize_routing ⇒ Object
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).
414 415 416 417 418 419 |
# File 'lib/initializer.rb', line 414 def initialize_routing return unless configuration.frameworks.include?(:action_controller) ActionController::Routing.controller_paths = configuration.controller_paths ActionController::Routing::Routes.configuration_file = configuration.routes_configuration_file ActionController::Routing::Routes.reload end |
#initialize_temporary_session_directory ⇒ Object
433 434 435 436 437 438 |
# File 'lib/initializer.rb', line 433 def initialize_temporary_session_directory if configuration.frameworks.include?(:action_controller) session_path = "#{configuration.root_path}/tmp/sessions/" ActionController::Base.[:tmpdir] = File.exist?(session_path) ? session_path : Dir::tmpdir end end |
#initialize_time_zone ⇒ Object
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.
442 443 444 445 446 447 448 449 450 451 452 453 454 |
# File 'lib/initializer.rb', line 442 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 |
#initialize_whiny_nils ⇒ Object
Loads support for “whiny nil” (noisy warnings when methods are invoked on nil
values) if Configuration#whiny_nils is true.
429 430 431 |
# File 'lib/initializer.rb', line 429 def initialize_whiny_nils require('active_support/whiny_nil') if configuration.whiny_nils end |
#install_gem_spec_stubs ⇒ Object
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.
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 |
# File 'lib/initializer.rb', line 176 def install_gem_spec_stubs 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 = %w(erails activesupport activerecord eactionpack 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 end end end end |
#load_application_initializers ⇒ Object
481 482 483 484 485 486 487 |
# File 'lib/initializer.rb', line 481 def load_application_initializers if gems_dependencies_loaded Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer| load(initializer) end end end |
#load_environment ⇒ Object
Loads the environment specified by Configuration#environment_path, which is typically one of development, test, or production.
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 |
# File 'lib/initializer.rb', line 301 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 |
#load_gems ⇒ Object
249 250 251 |
# File 'lib/initializer.rb', line 249 def load_gems @configuration.gems.each { |gem| gem.load } end |
#load_observers ⇒ Object
317 318 319 320 321 |
# File 'lib/initializer.rb', line 317 def load_observers if gems_dependencies_loaded && configuration.frameworks.include?(:active_record) ActiveRecord::Base.instantiate_observers end end |
#load_plugins ⇒ Object
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
291 292 293 |
# File 'lib/initializer.rb', line 291 def load_plugins plugin_loader.load_plugins end |
#plugin_loader ⇒ Object
295 296 297 |
# File 'lib/initializer.rb', line 295 def plugin_loader @plugin_loader ||= configuration.plugin_loader.new(self) end |
#prepare_dispatcher ⇒ Object
489 490 491 492 493 494 |
# File 'lib/initializer.rb', line 489 def prepare_dispatcher return unless configuration.frameworks.include?(:action_controller) require 'dispatcher' unless defined?(::Dispatcher) Dispatcher.define_dispatcher_callbacks(configuration.cache_classes) Dispatcher.new(RAILS_DEFAULT_LOGGER).send :run_callbacks, :prepare_dispatch end |
#process ⇒ Object
Sequentially step through all of the available initialization routines, in order (view execution order in source).
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 |
# File 'lib/initializer.rb', line 110 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 initialize_encoding initialize_database initialize_cache initialize_framework_caches initialize_logger initialize_framework_logging initialize_framework_views initialize_dependency_mechanism initialize_whiny_nils initialize_temporary_session_directory initialize_time_zone initialize_framework_settings add_support_load_paths load_gems load_plugins # pick up any gems that plugins depend on add_gem_load_paths load_gems check_gem_dependencies load_application_initializers # the framework is now fully initialized after_initialize # 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 end |
#require_frameworks ⇒ Object
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.
225 226 227 228 229 230 |
# File 'lib/initializer.rb', line 225 def require_frameworks configuration.frameworks.each { |framework| require(framework.to_s) } rescue LoadError => e # re-raise because Mongrel would swallow it raise e.to_s end |
#set_autoload_paths ⇒ Object
Set the paths from which Rails will automatically load source files, and the load_once paths.
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 |
# File 'lib/initializer.rb', line 206 def set_autoload_paths ActiveSupport::Dependencies.load_paths = configuration.load_paths.uniq ActiveSupport::Dependencies.load_once_paths = configuration.load_once_paths.uniq extra = ActiveSupport::Dependencies.load_once_paths - ActiveSupport::Dependencies.load_paths unless extra.empty? abort <<-end_error load_once_paths must be a subset of the load_paths. Extra items in load_once_paths: #{extra * ','} end_error end # Freeze the arrays so future modifications will fail rather than do nothing mysteriously configuration.load_once_paths.freeze end |
#set_load_path ⇒ Object
Set the $LOAD_PATH
based on the value of Configuration#load_paths. Duplicates are removed.
198 199 200 201 202 |
# File 'lib/initializer.rb', line 198 def set_load_path load_paths = configuration.load_paths + configuration.framework_paths load_paths.reverse_each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) } $LOAD_PATH.uniq! end |