Class Rails::Initializer
In: railties/lib/initializer.rb
Parent: Object

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.

Methods

add_support_load_paths   after_initialize   check_ruby_version   ensure_all_registered_plugins_are_loaded!   initialize_database   initialize_dependency_mechanism   initialize_encoding   initialize_framework_logging   initialize_framework_settings   initialize_framework_views   initialize_logger   initialize_routing   initialize_temporary_directories   initialize_whiny_nils   load_application_initializers   load_environment   load_observers   load_plugins   new   process   require_frameworks   run   set_autoload_paths   set_load_path  

Attributes

configuration  [R]  The Configuration instance used by this Initializer instance.
loaded_plugins  [R]  The set of loaded plugins.

Public Class methods

new(configuration)

Create a new Initializer instance that references the given Configuration instance.

[Source]

# File railties/lib/initializer.rb, line 55
    def initialize(configuration)
      @configuration = configuration
      @loaded_plugins = []
    end
run(command = :process, configuration = Configuration.new) {|configuration if block_given?| ...}

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.

[Source]

# File railties/lib/initializer.rb, line 46
    def self.run(command = :process, configuration = Configuration.new)
      yield configuration if block_given?
      initializer = new configuration
      initializer.send(command)
      initializer
    end

Public Instance methods

add_support_load_paths()

Add the load paths used by support functions such as the info controller

[Source]

# File railties/lib/initializer.rb, line 159
    def add_support_load_paths
    end
after_initialize()

Fires the user-supplied after_initialize block (Configuration#after_initialize)

[Source]

# File railties/lib/initializer.rb, line 326
    def after_initialize
      configuration.after_initialize_blocks.each do |block|
        block.call
      end
    end
check_ruby_version()

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.

[Source]

# File railties/lib/initializer.rb, line 120
    def check_ruby_version
      require 'ruby_version_check'
    end
initialize_database()

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.

[Source]

# File railties/lib/initializer.rb, line 223
    def initialize_database
      if configuration.frameworks.include?(:active_record)
        ActiveRecord::Base.configurations = configuration.database_configuration
        ActiveRecord::Base.establish_connection
      end
    end
initialize_dependency_mechanism()

Sets the dependency loading mechanism based on the value of Configuration#cache_classes.

[Source]

# File railties/lib/initializer.rb, line 290
    def initialize_dependency_mechanism
      Dependencies.mechanism = configuration.cache_classes ? :require : :load
    end
initialize_encoding()

This initialzation 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

[Source]

# File railties/lib/initializer.rb, line 215
    def initialize_encoding
      $KCODE='u'
    end
initialize_framework_logging()

Sets the logger for ActiveRecord, ActionController, and ActionMailer (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.

[Source]

# File railties/lib/initializer.rb, line 264
    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
    end
initialize_framework_settings()

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.

[Source]

# File railties/lib/initializer.rb, line 315
    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
    end
initialize_framework_views()

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.

[Source]

# File railties/lib/initializer.rb, line 274
    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()

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.

[Source]

# File railties/lib/initializer.rb, line 238
    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)
          logger.auto_flushing = false if configuration.environment == "production"
        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
initialize_routing()

If ActionController 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).

[Source]

# File railties/lib/initializer.rb, line 282
    def initialize_routing
      return unless configuration.frameworks.include?(:action_controller)
      ActionController::Routing.controller_paths = configuration.controller_paths
      ActionController::Routing::Routes.reload
    end
initialize_temporary_directories()

[Source]

# File railties/lib/initializer.rb, line 300
    def initialize_temporary_directories
      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

        cache_path = "#{configuration.root_path}/tmp/cache/"
        if File.exist?(cache_path)
          ActionController::Base.fragment_cache_store = :file_store, cache_path
        end
      end
    end
initialize_whiny_nils()

Loads support for "whiny nil" (noisy warnings when methods are invoked on nil values) if Configuration#whiny_nils is true.

[Source]

# File railties/lib/initializer.rb, line 296
    def initialize_whiny_nils
      require('active_support/whiny_nil') if configuration.whiny_nils
    end
load_application_initializers()

[Source]

# File railties/lib/initializer.rb, line 332
    def load_application_initializers
      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
        load(initializer)
      end
    end
load_environment()

Loads the environment specified by Configuration#environment_path, which is typically one of development, test, or production.

[Source]

# File railties/lib/initializer.rb, line 190
    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_observers()

[Source]

# File railties/lib/initializer.rb, line 206
    def load_observers
      if configuration.frameworks.include?(:active_record)
        ActiveRecord::Base.instantiate_observers
      end
    end
load_plugins()

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"]

Each plugin discovered in plugin_paths is initialized:

  • add its lib directory, if present, to the beginning of the load path
  • evaluate init.rb 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

[Source]

# File railties/lib/initializer.rb, line 178
    def load_plugins
      configuration.plugin_locators.each do |locator|
        locator.new(self).each do |plugin|
          plugin.load
        end
      end
      ensure_all_registered_plugins_are_loaded!
      $LOAD_PATH.uniq!
    end
process()

Sequentially step through all of the available initialization routines, in order:

[Source]

# File railties/lib/initializer.rb, line 83
    def process
      check_ruby_version
      set_load_path

      require_frameworks
      set_autoload_paths
      load_environment

      initialize_encoding
      initialize_database
      initialize_logger
      initialize_framework_logging
      initialize_framework_views
      initialize_dependency_mechanism
      initialize_whiny_nils
      initialize_temporary_directories
      initialize_framework_settings

      add_support_load_paths

      load_plugins

      # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
      load_observers

      # Routing must be initialized after plugins to allow the former to extend the routes
      initialize_routing

      # the framework is now fully initialized
      after_initialize

      load_application_initializers
    end
require_frameworks()

Requires all frameworks specified by the Configuration#frameworks list. By default, all frameworks (ActiveRecord, ActiveSupport, ActionPack, ActionMailer, and ActiveResource) are loaded.

[Source]

# File railties/lib/initializer.rb, line 154
    def require_frameworks
      configuration.frameworks.each { |framework| require(framework.to_s) }
    end
set_autoload_paths()

Set the paths from which Rails will automatically load source files, and the load_once paths.

[Source]

# File railties/lib/initializer.rb, line 134
    def set_autoload_paths
      Dependencies.load_paths = configuration.load_paths.uniq
      Dependencies.load_once_paths = configuration.load_once_paths.uniq

      extra = Dependencies.load_once_paths - Dependencies.load_paths
      unless extra.empty?
        abort "load_once_paths must be a subset of the load_paths.\nExtra items in load_once_paths: \#{extra * ','}\n"
      end

      # Freeze the arrays so future modifications will fail rather than do nothing mysteriously
      configuration.load_once_paths.freeze
    end
set_load_path()

Set the $LOAD_PATH based on the value of Configuration#load_paths. Duplicates are removed.

[Source]

# File railties/lib/initializer.rb, line 126
    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

Private Instance methods

ensure_all_registered_plugins_are_loaded!()

[Source]

# File railties/lib/initializer.rb, line 339
      def ensure_all_registered_plugins_are_loaded!
        unless configuration.plugins.nil?
          if configuration.plugins.detect {|plugin| plugin != :all && !loaded_plugins.include?( plugin)}
            missing_plugins = configuration.plugins - (loaded_plugins + [:all])
            raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence}"
          end
        end
      end

[Validate]