Class: Rails::Initializer

Inherits:
Object show all
Defined in:
lib/initializer.rb

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

Class Method Summary collapse

Instance Method Summary collapse

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.

Yields:



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.session_options[: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