Class: Rails::Application
- Defined in:
- lib/rails/application.rb,
lib/rails/application/finisher.rb,
lib/rails/application/bootstrap.rb,
lib/rails/application/configuration.rb,
lib/rails/application/routes_reloader.rb,
lib/rails/application/default_middleware_stack.rb
Overview
In Rails 3.0, a Rails::Application object was introduced which is nothing more than an Engine but with the responsibility of coordinating the whole boot process.
Initialization
Rails::Application is responsible for executing all railties and engines initializers. It also executes some bootstrap initializers (check Rails::Application::Bootstrap) and finishing initializers, after all the others are executed (check Rails::Application::Finisher).
Configuration
Besides providing the same configuration as Rails::Engine and Rails::Railtie, the application object has several specific configurations, for example “cache_classes”, “consider_all_requests_local”, “filter_parameters”, “logger” and so forth.
Check Rails::Application::Configuration to see them all.
Routes
The application object is also responsible for holding the routes and reloading routes whenever the files change in development.
Middlewares
The Application is also responsible for building the middleware stack.
Booting process
The application is also responsible for setting up and executing the booting process. From the moment you require “config/application.rb” in your app, the booting process goes like this:
1) require "config/boot.rb" to setup load paths
2) require railties and engines
3) Define Rails.application as "class MyApp::Application < Rails::Application"
4) Run config.before_configuration callbacks
5) Load config/environments/ENV.rb
6) Run config.before_initialize callbacks
7) Run Railtie#initializer defined by railties, engines and application.
One by one, each engine sets up its load paths, routes and runs its config/initializers/* files.
8) Custom Railtie#initializers added by railties, engines and applications are executed
9) Build the middleware stack and run to_prepare callbacks
10) Run config.before_eager_load and eager_load! if eager_load is true
11) Run config.after_initialize callbacks
Multiple Applications
If you decide to define multiple applications, then the first application that is initialized will be set to Rails.application
, unless you override it with a different application.
To create a new application, you can instantiate a new instance of a class that has already been created:
class Application < Rails::Application
end
first_application = Application.new
second_application = Application.new(config: first_application.config)
In the above example, the configuration from the first application was used to initialize the second application. You can also use the initialize_copy
on one of the applications to create a copy of the application which shares the configuration.
If you decide to define rake tasks, runners, or initializers in an application other than Rails.application
, then you must run those these manually.
Defined Under Namespace
Modules: Bootstrap, Finisher Classes: Configuration, DefaultMiddlewareStack, RoutesReloader
Constant Summary collapse
- INITIAL_VARIABLES =
[:config, :railties, :routes_reloader, :reloaders, :routes, :helpers, :app_env_config, :secrets]
Constants inherited from Railtie
Instance Attribute Summary collapse
-
#assets ⇒ Object
Returns the value of attribute assets.
-
#reloaders ⇒ Object
readonly
Returns the value of attribute reloaders.
-
#sandbox ⇒ Object
(also: #sandbox?)
Returns the value of attribute sandbox.
Class Method Summary collapse
Instance Method Summary collapse
-
#add_lib_to_load_path! ⇒ Object
This method is called just after an application inherits from Rails::Application, allowing the developer to load classes in lib and use them during application configuration.
-
#call(env) ⇒ Object
Implements call according to the Rack API.
-
#config ⇒ Object
:nodoc:.
-
#config=(configuration) ⇒ Object
:nodoc:.
-
#env_config ⇒ Object
Stores some of the Rails initial environment parameters which will be used by middlewares and engines to configure themselves.
-
#helpers_paths ⇒ Object
:nodoc:.
-
#initialize(initial_variable_values = {}, &block) ⇒ Application
constructor
A new instance of Application.
-
#initialize!(group = :default) ⇒ Object
Initialize the application passing the given group.
-
#initialized? ⇒ Boolean
Returns true if the application is initialized.
-
#initializer(name, opts = {}, &block) ⇒ Object
Sends the initializers to the
initializer
method defined in the Rails::Initializable module. -
#initializers ⇒ Object
:nodoc:.
-
#isolate_namespace(mod) ⇒ Object
Sends the
isolate_namespace
method up to the class method. -
#key_generator ⇒ Object
Return the application’s KeyGenerator.
-
#message_verifier(verifier_name) ⇒ Object
Returns a message verifier object.
-
#rake_tasks(&block) ⇒ Object
If you try to define a set of rake tasks on the instance, these will get passed up to the rake tasks defined on the application’s class.
-
#reload_routes! ⇒ Object
Reload application routes regardless if they changed or not.
-
#require_environment! ⇒ Object
:nodoc:.
-
#routes_reloader ⇒ Object
:nodoc:.
-
#runner(&blk) ⇒ Object
Sends any runner called in the instance of a new application up to the
runner
method defined in Rails::Railtie. -
#secrets ⇒ Object
:nodoc:.
-
#secrets=(secrets) ⇒ Object
:nodoc:.
-
#to_app ⇒ Object
:nodoc:.
-
#watchable_args ⇒ Object
Returns an array of file paths appended with a hash of directories-extensions suitable for ActiveSupport::FileUpdateChecker API.
Methods inherited from Engine
#app, #eager_load!, endpoint, #endpoint, find, #helpers, isolate_namespace, #load_console, #load_generators, #load_runner, #load_seed, #load_tasks, #railties, #routes, #routes?
Methods inherited from Railtie
abstract_railtie?, configure, #configure, console, generators, instance, railtie_name, #railtie_namespace, rake_tasks, respond_to_missing?, runner, subclasses
Methods included from Initializable
Constructor Details
#initialize(initial_variable_values = {}, &block) ⇒ Application
Returns a new instance of Application.
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
# File 'lib/rails/application.rb', line 110 def initialize(initial_variable_values = {}, &block) super() @initialized = false @reloaders = [] @routes_reloader = nil @app_env_config = nil @ordered_railties = nil @railties = nil @message_verifiers = {} Rails.application ||= self add_lib_to_load_path! ActiveSupport.run_load_hooks(:before_configuration, self) initial_variable_values.each do |variable_name, value| if INITIAL_VARIABLES.include?(variable_name) instance_variable_set("@#{variable_name}", value) end end instance_eval(&block) if block_given? end |
Instance Attribute Details
#assets ⇒ Object
Returns the value of attribute assets.
101 102 103 |
# File 'lib/rails/application.rb', line 101 def assets @assets end |
#reloaders ⇒ Object (readonly)
Returns the value of attribute reloaders.
103 104 105 |
# File 'lib/rails/application.rb', line 103 def reloaders @reloaders end |
#sandbox ⇒ Object Also known as: sandbox?
Returns the value of attribute sandbox.
101 102 103 |
# File 'lib/rails/application.rb', line 101 def sandbox @sandbox end |
Class Method Details
.inherited(base) ⇒ Object
88 89 90 91 |
# File 'lib/rails/application.rb', line 88 def inherited(base) super base.instance end |
Instance Method Details
#add_lib_to_load_path! ⇒ Object
This method is called just after an application inherits from Rails::Application, allowing the developer to load classes in lib and use them during application configuration.
class MyApplication < Rails::Application
require "my_backend" # in lib/my_backend
config.i18n.backend = MyBackend
end
Notice this method takes into consideration the default root path. So if you are changing config.root inside your application definition or having a custom Rails application, you will need to add lib to $LOAD_PATH on your own in case you need to load files in lib/ during the application configuration as well.
255 256 257 258 259 260 |
# File 'lib/rails/application.rb', line 255 def add_lib_to_load_path! #:nodoc: path = File.join config.root, 'lib' if File.exist?(path) && !$LOAD_PATH.include?(path) $LOAD_PATH.unshift(path) end end |
#call(env) ⇒ Object
Implements call according to the Rack API. It simply dispatches the request to the underlying middleware stack.
141 142 143 144 145 |
# File 'lib/rails/application.rb', line 141 def call(env) env["ORIGINAL_FULLPATH"] = build_original_fullpath(env) env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"] super(env) end |
#config ⇒ Object
:nodoc:
299 300 301 |
# File 'lib/rails/application.rb', line 299 def config #:nodoc: @config ||= Application::Configuration.new(find_root_with_flag("config.ru", Dir.pwd)) end |
#config=(configuration) ⇒ Object
:nodoc:
303 304 305 |
# File 'lib/rails/application.rb', line 303 def config=(configuration) #:nodoc: @config = configuration end |
#env_config ⇒ Object
Stores some of the Rails initial environment parameters which will be used by middlewares and engines to configure themselves.
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 |
# File 'lib/rails/application.rb', line 193 def env_config @app_env_config ||= begin validate_secret_key_config! super.merge({ "action_dispatch.parameter_filter" => config.filter_parameters, "action_dispatch.redirect_filter" => config.filter_redirect, "action_dispatch.secret_token" => config.secret_token, "action_dispatch.secret_key_base" => secrets.secret_key_base, "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions, "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local, "action_dispatch.logger" => Rails.logger, "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner, "action_dispatch.key_generator" => key_generator, "action_dispatch.http_auth_salt" => config.action_dispatch.http_auth_salt, "action_dispatch.signed_cookie_salt" => config.action_dispatch., "action_dispatch.encrypted_cookie_salt" => config.action_dispatch., "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch., "action_dispatch.cookies_serializer" => config.action_dispatch. }) end end |
#helpers_paths ⇒ Object
:nodoc:
333 334 335 |
# File 'lib/rails/application.rb', line 333 def helpers_paths #:nodoc: config.helpers_paths end |
#initialize!(group = :default) ⇒ Object
Initialize the application passing the given group. By default, the group is :default
286 287 288 289 290 291 |
# File 'lib/rails/application.rb', line 286 def initialize!(group=:default) #:nodoc: raise "Application has been already initialized." if @initialized run_initializers(group, self) @initialized = true self end |
#initialized? ⇒ Boolean
Returns true if the application is initialized.
135 136 137 |
# File 'lib/rails/application.rb', line 135 def initialized? @initialized end |
#initializer(name, opts = {}, &block) ⇒ Object
Sends the initializers to the initializer
method defined in the Rails::Initializable module. Each Rails::Application class has its own set of initializers, as defined by the Initializable module.
225 226 227 |
# File 'lib/rails/application.rb', line 225 def initializer(name, opts={}, &block) self.class.initializer(name, opts, &block) end |
#initializers ⇒ Object
:nodoc:
293 294 295 296 297 |
# File 'lib/rails/application.rb', line 293 def initializers #:nodoc: Bootstrap.initializers_for(self) + railties_initializers(super) + Finisher.initializers_for(self) end |
#isolate_namespace(mod) ⇒ Object
Sends the isolate_namespace
method up to the class method.
236 237 238 |
# File 'lib/rails/application.rb', line 236 def isolate_namespace(mod) self.class.isolate_namespace(mod) end |
#key_generator ⇒ Object
Return the application’s KeyGenerator
153 154 155 156 157 158 159 160 161 162 163 164 |
# File 'lib/rails/application.rb', line 153 def key_generator # number of iterations selected based on consultation with the google security # team. Details at https://github.com/rails/rails/pull/6952#issuecomment-7661220 @caching_key_generator ||= begin if secrets.secret_key_base key_generator = ActiveSupport::KeyGenerator.new(secrets.secret_key_base, iterations: 1000) ActiveSupport::CachingKeyGenerator.new(key_generator) else ActiveSupport::LegacyKeyGenerator.new(config.secret_token) end end end |
#message_verifier(verifier_name) ⇒ Object
Returns a message verifier object.
This verifier can be used to generate and verify signed messages in the application.
It is recommended not to use the same verifier for different things, so you can get different verifiers passing the verifier_name
argument.
Parameters
-
verifier_name
- the name of the message verifier.
Examples
= Rails.application.('sensitive_data').generate('my sensible data')
Rails.application.('sensitive_data').verify()
# => 'my sensible data'
See the ActiveSupport::MessageVerifier
documentation for more information.
184 185 186 187 188 189 |
# File 'lib/rails/application.rb', line 184 def (verifier_name) @message_verifiers[verifier_name] ||= begin secret = key_generator.generate_key(verifier_name.to_s) ActiveSupport::MessageVerifier.new(secret) end end |
#rake_tasks(&block) ⇒ Object
If you try to define a set of rake tasks on the instance, these will get passed up to the rake tasks defined on the application’s class.
218 219 220 |
# File 'lib/rails/application.rb', line 218 def rake_tasks(&block) self.class.rake_tasks(&block) end |
#reload_routes! ⇒ Object
Reload application routes regardless if they changed or not.
148 149 150 |
# File 'lib/rails/application.rb', line 148 def reload_routes! routes_reloader.reload! end |
#require_environment! ⇒ Object
:nodoc:
262 263 264 265 |
# File 'lib/rails/application.rb', line 262 def require_environment! #:nodoc: environment = paths["config/environment"].existent.first require environment if environment end |
#routes_reloader ⇒ Object
:nodoc:
267 268 269 |
# File 'lib/rails/application.rb', line 267 def routes_reloader #:nodoc: @routes_reloader ||= RoutesReloader.new end |
#runner(&blk) ⇒ Object
Sends any runner called in the instance of a new application up to the runner
method defined in Rails::Railtie.
231 232 233 |
# File 'lib/rails/application.rb', line 231 def runner(&blk) self.class.runner(&blk) end |
#secrets ⇒ Object
:nodoc:
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 |
# File 'lib/rails/application.rb', line 307 def secrets #:nodoc: @secrets ||= begin secrets = ActiveSupport::OrderedOptions.new yaml = config.paths["config/secrets"].first if File.exist?(yaml) require "erb" all_secrets = YAML.load(ERB.new(IO.read(yaml)).result) || {} env_secrets = all_secrets[Rails.env] secrets.merge!(env_secrets.symbolize_keys) if env_secrets end # Fallback to config.secret_key_base if secrets.secret_key_base isn't set secrets.secret_key_base ||= config.secret_key_base secrets end end |
#secrets=(secrets) ⇒ Object
:nodoc:
325 326 327 |
# File 'lib/rails/application.rb', line 325 def secrets=(secrets) #:nodoc: @secrets = secrets end |
#to_app ⇒ Object
:nodoc:
329 330 331 |
# File 'lib/rails/application.rb', line 329 def to_app #:nodoc: self end |
#watchable_args ⇒ Object
Returns an array of file paths appended with a hash of directories-extensions suitable for ActiveSupport::FileUpdateChecker API.
274 275 276 277 278 279 280 281 282 |
# File 'lib/rails/application.rb', line 274 def watchable_args #:nodoc: files, dirs = config.watchable_files.dup, config.watchable_dirs.dup ActiveSupport::Dependencies.autoload_paths.each do |path| dirs[path.to_s] = [:rb] end [files, dirs] end |