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)
- after_initialize
- after_initialize_blocks
- breakpoint_server
- breakpoint_server=
- builtin_directories
- database_configuration
- environment
- environment_path
- framework_paths
- gem
- load_once_paths
- load_once_paths=
- load_paths
- load_paths=
- middleware
- new
- plugins=
- reload_plugins?
- set_root_path!
- threadsafe!
- to_prepare
[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, vendor and 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_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 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.rb to make it reloadable:
ActiveSupport::Dependencies.autoload_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.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_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. |
Create a new Configuration instance, initialized with the default values.
[ show source ]
# File railties/lib/initializer.rb, line 862 862: def initialize 863: set_root_path! 864: 865: self.frameworks = default_frameworks 866: self.autoload_paths = default_autoload_paths 867: self.autoload_once_paths = default_autoload_once_paths 868: self.eager_load_paths = default_eager_load_paths 869: self.log_path = default_log_path 870: self.log_level = default_log_level 871: self.view_path = default_view_path 872: self.controller_paths = default_controller_paths 873: self.preload_frameworks = default_preload_frameworks 874: self.cache_classes = default_cache_classes 875: self.dependency_loading = default_dependency_loading 876: self.whiny_nils = default_whiny_nils 877: self.plugins = default_plugins 878: self.plugin_paths = default_plugin_paths 879: self.plugin_locators = default_plugin_locators 880: self.plugin_loader = default_plugin_loader 881: self.database_configuration_file = default_database_configuration_file 882: self.routes_configuration_file = default_routes_configuration_file 883: self.gems = default_gems 884: self.i18n = default_i18n 885: 886: for framework in default_frameworks 887: self.send("#{framework}=", Rails::OrderedOptions.new) 888: end 889: self.active_support = Rails::OrderedOptions.new 890: end
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.
[ show source ]
# File railties/lib/initializer.rb, line 947 947: def after_initialize(&after_initialize_block) 948: after_initialize_blocks << after_initialize_block if after_initialize_block 949: end
Returns the blocks added with Configuration#after_initialize
[ show source ]
# File railties/lib/initializer.rb, line 952 952: def after_initialize_blocks 953: @after_initialize_blocks ||= [] 954: end
Deprecated options:
[ show source ]
# File railties/lib/initializer.rb, line 843 843: def breakpoint_server(_ = nil) 844: $stderr.puts %( 845: ******************************************************************* 846: * config.breakpoint_server has been deprecated and has no effect. * 847: ******************************************************************* 848: ) 849: end
Alias for breakpoint_server
[ show source ]
# File railties/lib/initializer.rb, line 972 972: def builtin_directories 973: # Include builtins only in the development environment. 974: (environment == 'development') ? Dir["#{RAILTIES_PATH}/builtin/*/"] : [] 975: end
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.
[ show source ]
# File railties/lib/initializer.rb, line 927 927: def database_configuration 928: require 'erb' 929: YAML::load(ERB.new(IO.read(database_configuration_file)).result) 930: end
Return the currently selected environment. By default, it returns the value of the RAILS_ENV constant.
[ show source ]
# File railties/lib/initializer.rb, line 940 940: def environment 941: ::RAILS_ENV 942: end
The path to the current environment‘s file (development.rb, etc.). By default the file is at config/environments/#{environment}.rb.
[ show source ]
# File railties/lib/initializer.rb, line 934 934: def environment_path 935: "#{root_path}/config/environments/#{environment}.rb" 936: end
[ show source ]
# File railties/lib/initializer.rb, line 977 977: def framework_paths 978: paths = %w(railties railties/lib activesupport/lib) 979: paths << 'actionpack/lib' if frameworks.include?(:action_controller) || frameworks.include?(:action_view) 980: 981: [:active_record, :action_mailer, :active_resource, :action_web_service].each do |framework| 982: paths << "#{framework.to_s.gsub('_', '')}/lib" if frameworks.include?(framework) 983: end 984: 985: paths.map { |dir| "#{framework_root_path}/#{dir}" }.select { |dir| File.directory?(dir) } 986: end
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 => "http://code.whytheluckystiff.net"
To require a library be installed, but not attempt to load it, pass :lib => false
config.gem 'qrp', :version => '0.4.1', :lib => false
[ show source ]
# File railties/lib/initializer.rb, line 838 838: def gem(name, options = {}) 839: @gems << Rails::GemDependency.new(name, options) 840: end
Deprecated, use autoload_once_paths.
[ show source ]
# File railties/lib/initializer.rb, line 721 721: def load_once_paths 722: $stderr.puts("config.load_once_paths is deprecated and removed in Rails 3, please use autoload_once_paths instead") 723: autoload_once_paths 724: end
Deprecated, use autoload_once_paths=.
[ show source ]
# File railties/lib/initializer.rb, line 727 727: def load_once_paths=(paths) 728: $stderr.puts("config.load_once_paths= is deprecated and removed in Rails 3, please use autoload_once_paths= instead") 729: self.autoload_once_paths = paths 730: end
Deprecated, use autoload_paths.
[ show source ]
# File railties/lib/initializer.rb, line 705 705: def load_paths 706: $stderr.puts("config.load_paths is deprecated and removed in Rails 3, please use autoload_paths instead") 707: autoload_paths 708: end
Deprecated, use autoload_paths=.
[ show source ]
# File railties/lib/initializer.rb, line 711 711: def load_paths=(paths) 712: $stderr.puts("config.load_paths= is deprecated and removed in Rails 3, please use autoload_paths= instead") 713: self.autoload_paths = paths 714: end
[ show source ]
# File railties/lib/initializer.rb, line 967 967: def middleware 968: require 'action_controller' 969: ActionController::Dispatcher.middleware 970: end
[ show source ]
# File railties/lib/initializer.rb, line 766 766: def plugins=(plugins) 767: @plugins = plugins.nil? ? nil : plugins.map { |p| p.to_sym } 768: end
Returns true if plugin reloading is enabled.
[ show source ]
# File railties/lib/initializer.rb, line 804 804: def reload_plugins? 805: !!@reload_plugins 806: end
Set the root_path to RAILS_ROOT and canonicalize it.
[ show source ]
# File railties/lib/initializer.rb, line 893 893: def set_root_path! 894: raise 'RAILS_ROOT is not set' unless defined?(::RAILS_ROOT) 895: raise 'RAILS_ROOT is not a directory' unless File.directory?(::RAILS_ROOT) 896: 897: @root_path = 898: # Pathname is incompatible with Windows, but Windows doesn't have 899: # real symlinks so File.expand_path is safe. 900: if RUBY_PLATFORM =~ /(:?mswin|mingw)/ 901: File.expand_path(::RAILS_ROOT) 902: 903: # Otherwise use Pathname#realpath which respects symlinks. 904: else 905: Pathname.new(::RAILS_ROOT).realpath.to_s 906: end 907: 908: Object.const_set(:RELATIVE_RAILS_ROOT, ::RAILS_ROOT.dup) unless defined?(::RELATIVE_RAILS_ROOT) 909: ::RAILS_ROOT.replace @root_path 910: end
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.
[ show source ]
# File railties/lib/initializer.rb, line 916 916: def threadsafe! 917: self.preload_frameworks = true 918: self.cache_classes = true 919: self.dependency_loading = false 920: self.action_controller.allow_concurrency = true 921: self 922: end
Add a preparation callback that will run before every request in development mode, or before the first request in production.
See Dispatcher#to_prepare.
[ show source ]
# File railties/lib/initializer.rb, line 960 960: def to_prepare(&callback) 961: after_initialize do 962: require 'dispatcher' unless defined?(::Dispatcher) 963: Dispatcher.to_prepare(&callback) 964: end 965: end