The Configuration class holds all the parameters for the Initializer and ships with defaults that suites most Rails applications. But it's possible to overwrite everything. Usually, you'll create an Configuration file implicitly through the block running on the Initializer, but it's also possible to create the Configuration instance in advance and pass it in like this:

config =, config)
[RW] action_controller

A stub for setting options on ActionController::Base.

[RW] action_mailer

A stub for setting options on ActionMailer::Base.

[RW] action_view

A stub for setting options on ActionView::Base.

[RW] active_record

A stub for setting options on ActiveRecord::Base.

[RW] active_resource

A stub for setting options on ActiveResource::Base.

[RW] active_support

A stub for setting options on ActiveSupport.

[RW] autoload_once_paths

An array of paths from which Rails will automatically load from only once. All elements of this array must also be in autoload_paths.

[RW] autoload_paths

An array of additional paths to prepend to the load path. By default, all app, lib, vendorand mock paths are included in this list.

[RW] cache_classes

Whether or not classes should be cached (set to false if you want application classes to be reloaded on each request)

[RW] cache_store

The specific cache store to use. By default, the ActiveSupport::Cache::Store will be used.

[RW] controller_paths

The list of paths that should be searched for controllers. (Defaults to app/controllers.)

[RW] database_configuration_file

The path to the database configuration file to use. (Defaults to config/database.yml.)

[RW] dependency_loading

Enables or disables dependency loading during the request cycle. Setting dependency_loadingto true will allow new classes to be loaded during a request. Setting it to false will disable this behavior.

Those who want to run in a threaded environment should disable this option and eager load or require all there classes on initialization.

If cache_classesis disabled, dependency loaded will always be on.

[RW] eager_load_paths

An array of paths from which Rails will eager load on boot if cache classes is enabled. All elements of this array must also be in autoload_paths.

[RW] frameworks

The list of rails framework components that should be loaded. (Defaults to :active_record, :action_controller, :action_view, :action_mailer, and :active_resource).

[RW] gems

An array of gems that this rails application depends on. Rails will automatically load these gems during installation, and allow you to install any missing gems with:

rake gems:install

You can add gems with the gem method.

[RW] i18n

Accessor for i18n settings.

[RW] log_level

The log level to use for the default Rails logger. In production mode, this defaults to :info. In development mode, it defaults to :debug.

[RW] log_path

The path to the log file to use. Defaults to log/#{environment}.log (e.g. log/development.log or log/production.log).

[RW] logger

The specific logger to use. By default, a logger will be created and initialized using log_path and log_level, but a programmer may specifically set the logger to use via this accessor and it will be used directly.

[RW] metals

The list of metals to load. If this is set to nil, all metals will be loaded in alphabetical order. If this is set to [], no metals will be loaded. Otherwise metals will be loaded in the order specified

[RW] plugin_loader

The class that handles loading each plugin. Defaults to Rails::Plugin::Loader, but a sub class would have access to fine grained modification of the loading behavior. See the implementation of Rails::Plugin::Loader for more details.

[RW] plugin_locators

The classes that handle finding the desired plugins that you'd like to load for your application. By default it is the Rails::Plugin::FileSystemLocator which finds plugins to load in vendor/plugins. You can hook into gem location by subclassing Rails::Plugin::Locator and adding it onto the list of plugin_locators.

[RW] plugin_paths

The path to the root of the plugins directory. By default, it is in vendor/plugins.

[R] plugins

The list of plugins to load. If this is set to nil, all plugins will be loaded. If this is set to [], no plugins will be loaded. Otherwise, plugins will be loaded in the order specified.

[RW] preload_frameworks

Whether to preload all frameworks at startup.

[RW] reload_plugins

Enables or disables plugin reloading. You can get around this setting per plugin. If reload_plugins?is false, add this to your plugin's init.rbto make it reloadable:

ActiveSupport::Dependencies.autoload_once_paths.delete lib_path

If reload_plugins?is true, add this to your plugin's init.rbto only load it once:

ActiveSupport::Dependencies.autoload_once_paths << lib_path
[R] root_path

The application's base directory.

[RW] routes_configuration_file

The path to the routes configuration file to use. (Defaults to config/routes.rb.)

[RW] time_zone

Sets the default time_zone. Setting this will enable time_zoneawareness for Active Record models and set the Active Record default timezone to :utc.

[RW] view_path

The root of the application's views. (Defaults to app/views.)

[RW] whiny_nils

Set to trueif you want to be warned (noisily) when you try to invoke any method of nil. Set to falsefor the standard Ruby behavior.

Class Public methods

Create a new Configuration instance, initialized with the default values.

# File railties/lib/initializer.rb, line 859
def initialize
  self.frameworks                   = default_frameworks
  self.autoload_paths               = default_autoload_paths
  self.autoload_once_paths          = default_autoload_once_paths
  self.eager_load_paths             = default_eager_load_paths
  self.log_path                     = default_log_path
  self.log_level                    = default_log_level
  self.view_path                    = default_view_path
  self.controller_paths             = default_controller_paths
  self.preload_frameworks           = default_preload_frameworks
  self.cache_classes                = default_cache_classes
  self.dependency_loading           = default_dependency_loading
  self.whiny_nils                   = default_whiny_nils
  self.plugins                      = default_plugins
  self.plugin_paths                 = default_plugin_paths
  self.plugin_locators              = default_plugin_locators
  self.plugin_loader                = default_plugin_loader
  self.database_configuration_file  = default_database_configuration_file
  self.routes_configuration_file    = default_routes_configuration_file
  self.gems                         = default_gems
  self.i18n                         = default_i18n
  for framework in default_frameworks
  self.active_support =
Instance Public methods

Adds a block which will be executed after rails has been fully initialized. Useful for per-environment configuration which depends on the framework being fully initialized.

# File railties/lib/initializer.rb, line 944
def after_initialize(&after_initialize_block)
  after_initialize_blocks << after_initialize_block if after_initialize_block

Returns the blocks added with #after_initialize

# File railties/lib/initializer.rb, line 949
def after_initialize_blocks
  @after_initialize_blocks ||= []
breakpoint_server(_ = nil)

Deprecated options:

Also aliased as: breakpoint_server=
# File railties/lib/initializer.rb, line 840
def breakpoint_server(_ = nil)
  $stderr.puts %Q(
  * config.breakpoint_server has been deprecated and has no effect. *
breakpoint_server=(_ = nil)
# File railties/lib/initializer.rb, line 969
def builtin_directories
  # Include builtins only in the development environment.
  (environment == 'development') ? Dir["#{RAILTIES_PATH}/builtin/*/"] : []

Loads and returns the contents of the database_configuration_file. The contents of the file are processed via ERB before being sent through YAML::load.

# File railties/lib/initializer.rb, line 924
def database_configuration
  require 'erb'

Return the currently selected environment. By default, it returns the value of the RAILS_ENV constant.

# File railties/lib/initializer.rb, line 937
def environment

The path to the current environment's file ( development.rb, etc.). By default the file is at config/environments/#{environment}.rb.

# File railties/lib/initializer.rb, line 931
def environment_path
# File railties/lib/initializer.rb, line 974
def framework_paths
  paths = %w(railties railties/lib activesupport/lib)
  paths << 'actionpack/lib' if frameworks.include?(:action_controller) || frameworks.include?(:action_view)
  [:active_record, :action_mailer, :active_resource, :action_web_service].each do |framework|
    paths << "#{framework.to_s.gsub('_', '')}/lib" if frameworks.include?(framework)
  end { |dir| "#{framework_root_path}/#{dir}" }.select { |dir| }
gem(name, options = {})

Adds a single Gem dependency to the rails application. By default, it will require the library with the same name as the gem. Use :lib to specify a different name.

# gem 'aws-s3', '>= 0.4.0'
# require 'aws/s3'
config.gem 'aws-s3', :lib => 'aws/s3', :version => '>= 0.4.0',    :source => ""

To require a library be installed, but not attempt to load it, pass :lib => false

config.gem 'qrp', :version => '0.4.1', :lib => false
# File railties/lib/initializer.rb, line 835
def gem(name, options = {})
  @gems <<, options)

Deprecated, use autoload_once_paths.

# File railties/lib/initializer.rb, line 718
def load_once_paths
  $stderr.puts("config.load_once_paths is deprecated and removed in Rails 3, please use autoload_once_paths instead")

Deprecated, use #autoload_once_paths=.

# File railties/lib/initializer.rb, line 724
def load_once_paths=(paths)
  $stderr.puts("config.load_once_paths= is deprecated and removed in Rails 3, please use autoload_once_paths= instead")
  self.autoload_once_paths = paths

Deprecated, use autoload_paths.

# File railties/lib/initializer.rb, line 702
def load_paths
  $stderr.puts("config.load_paths is deprecated and removed in Rails 3, please use autoload_paths instead")

Deprecated, use #autoload_paths=.

# File railties/lib/initializer.rb, line 708
def load_paths=(paths)
  $stderr.puts("config.load_paths= is deprecated and removed in Rails 3, please use autoload_paths= instead")
  self.autoload_paths = paths
# File railties/lib/initializer.rb, line 964
def middleware
  require 'action_controller'
# File railties/lib/initializer.rb, line 763
def plugins=(plugins)
  @plugins = plugins.nil? ? nil : { |p| p.to_sym }

Returns true if plugin reloading is enabled.

# File railties/lib/initializer.rb, line 801
def reload_plugins?

Set the #root_path to RAILS_ROOT and canonicalize it.

# File railties/lib/initializer.rb, line 890
def set_root_path!
  raise 'RAILS_ROOT is not set' unless defined?(::RAILS_ROOT)
  raise 'RAILS_ROOT is not a directory' unless
  @root_path =
    # Pathname is incompatible with Windows, but Windows doesn't have
    # real symlinks so File.expand_path is safe.
    if RUBY_PLATFORM =~ /(:?mswin|mingw)/
    # Otherwise use Pathname#realpath which respects symlinks.
  Object.const_set(:RELATIVE_RAILS_ROOT, ::RAILS_ROOT.dup) unless defined?(::RELATIVE_RAILS_ROOT)
  ::RAILS_ROOT.replace @root_path

Enable threaded mode. Allows concurrent requests to controller actions and multiple database connections. Also disables automatic dependency loading after boot, and disables reloading code on every request, as these are fundamentally incompatible with thread safety.

# File railties/lib/initializer.rb, line 913
def threadsafe!
  self.preload_frameworks = true
  self.cache_classes = true
  self.dependency_loading = false
  self.action_controller.allow_concurrency = true

Add a preparation callback that will run before every request in development mode, or before the first request in production.

See Dispatcher#to_prepare.

# File railties/lib/initializer.rb, line 957
def to_prepare(&callback)
  after_initialize do
    require 'dispatcher' unless defined?(::Dispatcher)