Class: Rails::Configuration

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 = Rails::Configuration.new
  Rails::Initializer.run(:process, config)

Methods

after_initialize
after_initialize_blocks
breakpoint_server
breakpoint_server=
builtin_directories
database_configuration
environment
environment_path
framework_paths
gem
middleware
new
plugins=
reload_plugins?
set_root_path!
threadsafe!
to_prepare

Attributes

[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]	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_loading` to 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_classes` is 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 `load_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]	load_once_paths	An array of paths from which Rails will automatically load from only once. All elements of this array must also be in `load_paths`.
[RW]	load_paths	An array of additional paths to prepend to the load path. By default, all `app`, `lib`, `vendor` and mock paths are included in this list.
[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.rb` to make it reloadable: ActiveSupport::Dependencies.load_once_paths.delete lib_path If `reload_plugins?` is true, add this to your plugin‘s `init.rb` to only load it once: ActiveSupport::Dependencies.load_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_zone` awareness 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 `true` if you want to be warned (noisily) when you try to invoke any method of `nil`. Set to `false` for the standard Ruby behavior.

Public Class methods

new()

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