Class: Rails::Application

Inherits:
Engine show all
Defined in:
railties/lib/rails/application.rb,
railties/lib/rails/application/finisher.rb,
railties/lib/rails/application/bootstrap.rb,
railties/lib/rails/application/configuration.rb,
railties/lib/rails/application/routes_reloader.rb,
railties/lib/rails/application/default_middleware_stack.rb

Overview

An Engine 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 enable_reloading, 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 set up 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 and 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.

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]

Constants included from ActiveSupport::Callbacks

ActiveSupport::Callbacks::CALLBACK_FILTER_TYPES

Constants inherited from Railtie

Railtie::ABSTRACT_RAILTIES

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Engine

#app, #call, endpoint, #endpoint, find, find_root_with_flag, #helpers, isolate_namespace, #load_console, #load_runner, #load_seed, #load_server, #load_tasks, #railties, #routes, #routes?

Methods included from ActiveSupport::Callbacks

#run_callbacks

Methods included from ActiveSupport::Concern

#append_features, #class_methods, extended, #included, #prepend_features, #prepended

Methods inherited from Railtie

<=>, abstract_railtie?, #configure, configure, console, generators, #inspect, railtie_name, #railtie_namespace, rake_tasks, runner, server, subclasses

Methods included from ActiveSupport::DescendantsTracker

clear, #descendants, descendants, disable_clear!, reject!, subclasses

Methods included from Initializable

included, #run_initializers

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
133
134
 
# File 'railties/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
  @key_generators    = {}
  @message_verifiers = nil
  @deprecators       = nil
  @ran_load_hooks    = false
  @revision          = nil
  @revision_initialized = false

  @executor          = Class.new(ActiveSupport::Executor)
  @reloader          = Class.new(ActiveSupport::Reloader)
  @reloader.executor = @executor

  @autoloaders = Rails::Autoloaders.new

  # are these actually used?
  @initial_variable_values = initial_variable_values
  @block = block
end

Instance Attribute Details

#assets ⇒ Object

Returns the value of attribute assets.



101
102
103
 
# File 'railties/lib/rails/application.rb', line 101

def assets
  @assets
end

#autoloaders ⇒ Object (readonly)

Returns the value of attribute autoloaders.



103
104
105
 
# File 'railties/lib/rails/application.rb', line 103

def autoloaders
  @autoloaders
end

#config ⇒ Object

:nodoc:



485
486
487
 
# File 'railties/lib/rails/application.rb', line 485

def config # :nodoc:
  @config ||= Application::Configuration.new(self.class.find_root(self.class.called_from))
end

#credentials ⇒ Object

Returns an ActiveSupport::EncryptedConfiguration instance for the credentials file specified by config.credentials.content_path.

By default, config.credentials.content_path will point to either config/credentials/#{environment}.yml.enc for the current environment (for example, config/credentials/production.yml.enc for the production environment), or config/credentials.yml.enc if that file does not exist.

The encryption key is taken from either ENV["RAILS_MASTER_KEY"], or from the file specified by config.credentials.key_path. By default, config.credentials.key_path will point to either config/credentials/#{environment}.key for the current environment, or config/master.key if that file does not exist.

Is best used via #creds to ensure that values can be overwritten via ENV (or .env in dev).



606
607
608
 
# File 'railties/lib/rails/application.rb', line 606

def credentials
  @credentials ||= encrypted(config.credentials.content_path, key_path: config.credentials.key_path)
end

#creds ⇒ Object

Returns an ActiveSupport::CombinedConfiguration instance that combines access to the encrypted credentials available via #credentials and keys used for the same purpose in ENV.

In the development environment, .env variables are also included, and looked up after ENV and before the encrypted credentials.

This allows application creds to be accessed in a uniform way regardless of where they’re being provided. You don’t have to change app code when you move from ENV to encrypted credentials or vice versa.

Examples:

Rails.app.creds.require(:db_password)
Rails.app.creds.require(:aws, :access_key_id)
Rails.app.creds.option(:cache_host, default: "cache-host-1")
Rails.app.creds.option(:cache_host, default: -> { HostProvider.cache })



532
533
534
535
536
537
538
 
# File 'railties/lib/rails/application.rb', line 532

def creds
  if Rails.env.development?
    @creds ||= ActiveSupport::CombinedConfiguration.new(envs, dotenvs, credentials)
  else
    @creds ||= ActiveSupport::CombinedConfiguration.new(envs, credentials)
  end
end

#executor ⇒ Object (readonly)

Returns the value of attribute executor.



103
104
105
 
# File 'railties/lib/rails/application.rb', line 103

def executor
  @executor
end

#reloader ⇒ Object (readonly)

Returns the value of attribute reloader.



103
104
105
 
# File 'railties/lib/rails/application.rb', line 103

def reloader
  @reloader
end

#reloaders ⇒ Object (readonly)

Returns the value of attribute reloaders.



103
104
105
 
# File 'railties/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 'railties/lib/rails/application.rb', line 101

def sandbox
  @sandbox
end

Class Method Details

.add_lib_to_load_path!(root) ⇒ 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.



441
442
443
444
445
446
 
# File 'railties/lib/rails/application.rb', line 441

def self.add_lib_to_load_path!(root) # :nodoc:
  path = File.join(root, "lib")
  if File.exist?(path) && !$LOAD_PATH.include?(path)
    $LOAD_PATH.unshift(path)
  end
end

.create(initial_variable_values = {}, &block) ⇒ Object 



85
86
87
 
# File 'railties/lib/rails/application.rb', line 85

def create(initial_variable_values = {}, &block)
  new(initial_variable_values, &block).run_load_hooks!
end

.find_root(from) ⇒ Object 



89
90
91
 
# File 'railties/lib/rails/application.rb', line 89

def find_root(from)
  find_root_with_flag "config.ru", from, Dir.pwd
end

.inherited(base) ⇒ Object 



72
73
74
75
76
77
78
79
 
# File 'railties/lib/rails/application.rb', line 72

def inherited(base)
  super
  Rails.app_class = base
  # lib has to be added to $LOAD_PATH unconditionally, even if it's in the
  # autoload paths and config.add_autoload_paths_to_load_path is false.
  add_lib_to_load_path!(find_root(base.called_from))
  ActiveSupport.run_load_hooks(:before_configuration, base)
end

.instance ⇒ Object 



81
82
83
 
# File 'railties/lib/rails/application.rb', line 81

def instance
  super.run_load_hooks!
end

Instance Method Details

#config_for(name, env: Rails.env) ⇒ Object

Convenience for loading config/foo.yml for the current Rails env. Example:

# config/exception_notification.yml:
production:
  url: http://127.0.0.1:8080
  namespace: my_app_production

development:
  url: http://localhost:3001
  namespace: my_app_development


# config/environments/production.rb
Rails.application.configure do
  config.middleware.use ExceptionNotifier, config_for(:exception_notification)
end

You can also store configurations in a shared section which will be merged with the environment configuration

# config/example.yml
shared:
  foo:
    bar:
      baz: 1

development:
  foo:
    bar:
      qux: 2


# development environment
Rails.application.config_for(:example)[:foo][:bar]
# => { baz: 1, qux: 2 }



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
 
# File 'railties/lib/rails/application.rb', line 295

def config_for(name, env: Rails.env)
  yaml = name.is_a?(Pathname) ? name : Pathname.new("#{paths["config"].existent.first}/#{name}.yml")

  if yaml.exist?
    all_configs    = ActiveSupport::ConfigurationFile.parse(yaml).deep_symbolize_keys
    config, shared = all_configs[env.to_sym], all_configs[:shared]

    if shared
      config = {} if config.nil? && shared.is_a?(Hash)
      if config.is_a?(Hash) && shared.is_a?(Hash)
        config = shared.deep_merge(config)
      elsif config.nil?
        config = shared
      end
    end

    if config.is_a?(Hash)
      config = ActiveSupport::OrderedOptions.new.update(config)
    end

    config
  else
    raise "Could not load configuration. No such file - #{yaml}"
  end
end

#console(&blk) ⇒ Object

Sends any console called in the instance of a new application up to the console method defined in Rails::Railtie.



377
378
379
 
# File 'railties/lib/rails/application.rb', line 377

def console(&blk)
  self.class.console(&blk)
end

#deprecators ⇒ Object

A managed collection of deprecators (ActiveSupport::Deprecation::Deprecators). The collection’s configuration methods affect all deprecators in the collection. Additionally, the collection’s silence method silences all deprecators in the collection for the duration of a given block.



251
252
253
254
255
 
# File 'railties/lib/rails/application.rb', line 251

def deprecators
  @deprecators ||= ActiveSupport::Deprecation::Deprecators.new.tap do |deprecators|
    deprecators[:railties] = Rails.deprecator
  end
end

#dotenvs(path = Rails.root.join(".env")) ⇒ Object

Returns an ActiveSupport::DotEnvConfiguration instance that provides access to the variables in .env through symbol-based lookup with explicit methods for required and optional values. This is the same interface offered by #envs and can be accessed in a combined manner via #creds.

The .env file format supports:

  • Lines with KEY=value pairs

  • Comments starting with #

  • Empty lines (ignored)

  • Quoted values (single or double quotes)

  • Variable interpolation with $VAR syntax

  • Command execution with $(command) syntax

Examples:

Rails.app.dotenvs.require(:db_password) # DB_PASSWORD from .env
Rails.app.dotenvs.require(:aws, :access_key_id) # AWS__ACCESS_KEY_ID from .env
Rails.app.dotenvs.option(:cache_host) # CACHE_HOST from .env or nil
Rails.app.dotenvs.option(:cache_host, default: "cache-host-1") # CACHE_HOST from .env or "cache-host-1"
Rails.app.dotenvs.option(:cache_host, default: -> { HostProvider.cache }) # CACHE_HOST from .env or HostProvider.cache

In development mode, this configuration backend is automatically part of Rails.app.creds.



586
587
588
 
# File 'railties/lib/rails/application.rb', line 586

def dotenvs(path = Rails.root.join(".env"))
  @dotenvs ||= ActiveSupport::DotEnvConfiguration.new(path)
end

#eager_load! ⇒ Object

Eager loads the application code.



664
665
666
 
# File 'railties/lib/rails/application.rb', line 664

def eager_load!
  Rails.autoloaders.each(&:eager_load)
end

#encrypted(path, key_path: "config/master.key", env_key: "RAILS_MASTER_KEY") ⇒ Object

Returns an ActiveSupport::EncryptedConfiguration instance for an encrypted file. By default, the encryption key is taken from either ENV["RAILS_MASTER_KEY"], or from the config/master.key file.

my_config = Rails.application.encrypted("config/my_config.enc")

my_config.read
# => "foo:\n  bar: 123\n"

my_config.foo.bar
# => 123

Encrypted files can be edited with the bin/rails encrypted:edit command. (See the output of bin/rails encrypted:edit --help for more information.)



625
626
627
628
629
630
631
632
 
# File 'railties/lib/rails/application.rb', line 625

def encrypted(path, key_path: "config/master.key", env_key: "RAILS_MASTER_KEY")
  ActiveSupport::EncryptedConfiguration.new(
    config_path: Rails.root.join(path),
    key_path: Rails.root.join(key_path),
    env_key: env_key,
    raise_if_missing_key: config.require_master_key
  )
end

#env_config ⇒ Object

Stores some of the Rails initial environment parameters which will be used by middlewares and engines to configure themselves.



323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'railties/lib/rails/application.rb', line 323

def env_config
  @app_env_config ||= super.merge(
      "action_dispatch.parameter_filter" => filter_parameters,
      "action_dispatch.redirect_filter" => config.filter_redirect,
      "action_dispatch.secret_key_base" => secret_key_base,
      "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions,
      "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local,
      "action_dispatch.log_rescued_responses" => config.action_dispatch.log_rescued_responses,
      "action_dispatch.debug_exception_log_level" => ActiveSupport::Logger.const_get(config.action_dispatch.debug_exception_log_level.to_s.upcase),
      "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.signed_cookie_salt,
      "action_dispatch.encrypted_cookie_salt" => config.action_dispatch.encrypted_cookie_salt,
      "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch.encrypted_signed_cookie_salt,
      "action_dispatch.authenticated_encrypted_cookie_salt" => config.action_dispatch.authenticated_encrypted_cookie_salt,
      "action_dispatch.use_authenticated_cookie_encryption" => config.action_dispatch.use_authenticated_cookie_encryption,
      "action_dispatch.encrypted_cookie_cipher" => config.action_dispatch.encrypted_cookie_cipher,
      "action_dispatch.signed_cookie_digest" => config.action_dispatch.signed_cookie_digest,
      "action_dispatch.cookies_serializer" => config.action_dispatch.cookies_serializer,
      "action_dispatch.cookies_digest" => config.action_dispatch.cookies_digest,
      "action_dispatch.cookies_rotations" => config.action_dispatch.cookies_rotations,
      "action_dispatch.cookies_same_site_protection" => coerce_same_site_protection(config.action_dispatch.cookies_same_site_protection),
      "action_dispatch.use_cookies_with_metadata" => config.action_dispatch.use_cookies_with_metadata,
      "action_dispatch.content_security_policy" => config.content_security_policy,
      "action_dispatch.content_security_policy_report_only" => config.content_security_policy_report_only,
      "action_dispatch.content_security_policy_nonce_generator" => config.content_security_policy_nonce_generator,
      "action_dispatch.content_security_policy_nonce_directives" => config.content_security_policy_nonce_directives,
      "action_dispatch.permissions_policy" => config.permissions_policy,
    )
end

#envs ⇒ Object

Returns an ActiveSupport::EnvConfiguration instance that provides access to the ENV variables through symbol-based lookup with explicit methods for required and optional values. This is the same interface offered by #credentials and can be accessed in a combined manner via #creds.

Examples:

Rails.app.envs.require(:db_password) # ENV,fetch("DB_PASSWORD")
Rails.app.envs.require(:aws, :access_key_id) # ENV.fetch("AWS__ACCESS_KEY_ID")
Rails.app.envs.option(:cache_host) # ENV["CACHE_HOST"]
Rails.app.envs.option(:cache_host, default: "cache-host-1") # ENV.fetch("CACHE_HOST", "cache-host-1")
Rails.app.envs.option(:cache_host, default: -> { HostProvider.cache }) # ENV.fetch("CACHE_HOST") { HostProvider.cache }



560
561
562
 
# File 'railties/lib/rails/application.rb', line 560

def envs
  @envs ||= ActiveSupport::EnvConfiguration.new
end

#generators(&blk) ⇒ Object

Sends any generators called in the instance of a new application up to the generators method defined in Rails::Railtie.



383
384
385
 
# File 'railties/lib/rails/application.rb', line 383

def generators(&blk)
  self.class.generators(&blk)
end

#helpers_paths ⇒ Object

:nodoc:



638
639
640
 
# File 'railties/lib/rails/application.rb', line 638

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



472
473
474
475
476
477
 
# File 'railties/lib/rails/application.rb', line 472

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.

Returns:

  • (Boolean) 


137
138
139
 
# File 'railties/lib/rails/application.rb', line 137

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.



365
366
367
 
# File 'railties/lib/rails/application.rb', line 365

def initializer(name, opts = {}, &block)
  self.class.initializer(name, opts, &block)
end

#initializers ⇒ Object

:nodoc:



479
480
481
482
483
 
# File 'railties/lib/rails/application.rb', line 479

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.



394
395
396
 
# File 'railties/lib/rails/application.rb', line 394

def isolate_namespace(mod)
  self.class.isolate_namespace(mod)
end

#key_generator(secret_key_base = self.secret_key_base) ⇒ Object

Returns a key generator (ActiveSupport::CachingKeyGenerator) for a specified secret_key_base. The return value is memoized, so additional calls with the same secret_key_base will return the same key generator instance.



179
180
181
182
183
184
185
 
# File 'railties/lib/rails/application.rb', line 179

def key_generator(secret_key_base = self.secret_key_base)
  # number of iterations selected based on consultation with the google security
  # team. Details at https://github.com/rails/rails/pull/6952#issuecomment-7661220
  @key_generators[secret_key_base] ||= ActiveSupport::CachingKeyGenerator.new(
    ActiveSupport::KeyGenerator.new(secret_key_base, iterations: 1000)
  )
end

#load_generators(app = self) ⇒ Object

:nodoc:



658
659
660
661
 
# File 'railties/lib/rails/application.rb', line 658

def load_generators(app = self) # :nodoc:
  app.ensure_generator_templates_added
  super
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.

For instance, ActiveStorage::Blob.signed_id_verifier is implemented using this feature, which assures that the IDs strings haven’t been tampered with and are safe to use in a finder.

See the ActiveSupport::MessageVerifier documentation for more information.

Parameters

  • verifier_name - the name of the message verifier.

Examples

message = Rails.application.message_verifier('my_purpose').generate('data to sign against tampering')
Rails.application.message_verifier('my_purpose').verify(message)
# => 'data to sign against tampering'



243
244
245
 
# File 'railties/lib/rails/application.rb', line 243

def message_verifier(verifier_name)
  message_verifiers[verifier_name]
end

#message_verifiers ⇒ Object

Returns a message verifier factory (ActiveSupport::MessageVerifiers). This factory can be used as a central point to configure and create message verifiers (ActiveSupport::MessageVerifier) for your application.

By default, message verifiers created by this factory will generate messages using the default ActiveSupport::MessageVerifier options. You can override these options with a combination of ActiveSupport::MessageVerifiers#clear_rotations and ActiveSupport::MessageVerifiers#rotate. However, this must be done prior to building any message verifier instances. For example, in a before_initialize block:

# Use `url_safe: true` when generating messages
config.before_initialize do |app|
  app.message_verifiers.clear_rotations
  app.message_verifiers.rotate(url_safe: true)
end

Message verifiers created by this factory will always use a secret derived from #secret_key_base when generating messages. clear_rotations will not affect this behavior. However, older secret_key_base values can be rotated for verifying messages:

# Fall back to old `secret_key_base` when verifying messages
config.before_initialize do |app|
  app.message_verifiers.rotate(secret_key_base: "old secret_key_base")
end



215
216
217
218
219
220
 
# File 'railties/lib/rails/application.rb', line 215

def message_verifiers
  @message_verifiers ||=
    ActiveSupport::MessageVerifiers.new do |salt, secret_key_base: self.secret_key_base|
      key_generator(secret_key_base).generate_key(salt)
    end.rotate_defaults
end

#migration_railties ⇒ Object

Return an array of railties respecting the order they’re loaded and the order specified by the railties_order config.

While running initializers we need engines in reverse order here when copying migrations from railties ; we need them in the order given by railties_order.



654
655
656
 
# File 'railties/lib/rails/application.rb', line 654

def migration_railties # :nodoc:
  ordered_railties.flatten - [self]
end

#name ⇒ Object

Returns the dasherized application name.

MyApp::Application.new.name => "my-app"



144
145
146
 
# File 'railties/lib/rails/application.rb', line 144

def name
  self.class.name.underscore.dasherize.delete_suffix("/application")
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.



358
359
360
 
# File 'railties/lib/rails/application.rb', line 358

def rake_tasks(&block)
  self.class.rake_tasks(&block)
end

#reload_routes! ⇒ Object

Reload application routes regardless if they changed or not.



163
164
165
166
167
168
169
 
# File 'railties/lib/rails/application.rb', line 163

def reload_routes!
  if routes_reloader.execute_unless_loaded
    routes_reloader.loaded = false
  else
    routes_reloader.reload!
  end
end

#reload_routes_unless_loaded ⇒ Object

:nodoc:



171
172
173
 
# File 'railties/lib/rails/application.rb', line 171

def reload_routes_unless_loaded # :nodoc:
  initialized? && routes_reloader.execute_unless_loaded
end

#require_environment! ⇒ Object

:nodoc:



448
449
450
451
 
# File 'railties/lib/rails/application.rb', line 448

def require_environment! # :nodoc:
  environment = paths["config/environment"].existent.first
  require environment if environment
end

#revision ⇒ Object

Returns the application’s revision (deployment identifier). Useful for error reporting and deployment verification.

Set via config.revision (string or proc) or REVISION file. Always either a String or nil.



404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'railties/lib/rails/application.rb', line 404

def revision
  unless @revision_initialized
    @revision = begin
      root.join("REVISION").read.strip.presence
    rescue SystemCallError
      r, w = IO.pipe
      success = system("git", "-C", root.to_s, "rev-parse", "HEAD", in: File::NULL, err: File::NULL, out: w)
      w.close
      rev = r.read.strip
      r.close
      rev if success
    end
    @revision_initialized = true
  end
  @revision
end

#revision=(rev) ⇒ Object

Rails internal API



423
424
425
426
 
# File 'railties/lib/rails/application.rb', line 423

def revision=(rev) # :nodoc:
  @revision = rev&.to_s
  @revision_initialized = true
end

#routes_reloader ⇒ Object

:nodoc:



453
454
455
 
# File 'railties/lib/rails/application.rb', line 453

def routes_reloader # :nodoc:
  @routes_reloader ||= RoutesReloader.new(file_watcher: config.file_watcher)
end

#run_load_hooks! ⇒ Object

:nodoc:



148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'railties/lib/rails/application.rb', line 148

def run_load_hooks! # :nodoc:
  return self if @ran_load_hooks
  @ran_load_hooks = true

  @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
  self
end

#runner(&blk) ⇒ Object

Sends any runner called in the instance of a new application up to the runner method defined in Rails::Railtie.



371
372
373
 
# File 'railties/lib/rails/application.rb', line 371

def runner(&blk)
  self.class.runner(&blk)
end

#secret_key_base ⇒ Object

The secret_key_base is used as the input secret to the application’s key generator, which in turn is used to create all ActiveSupport::MessageVerifier and ActiveSupport::MessageEncryptor instances, including the ones that sign and encrypt cookies.

We look for it first in ENV["SECRET_KEY_BASE"], then in credentials.secret_key_base. For most applications, the correct place to store it is in the encrypted credentials file.

In development and test, if the secret_key_base is still empty, it is randomly generated and stored in a temporary file in tmp/local_secret.txt.

Generating a random secret_key_base and storing it in tmp/local_secret.txt can also be triggered by setting ENV["SECRET_KEY_BASE_DUMMY"]. This is useful when precompiling assets for production as part of a build step that otherwise does not need access to the production secrets.

Dockerfile example: RUN SECRET_KEY_BASE_DUMMY=1 bundle exec rails assets:precompile.



511
512
513
 
# File 'railties/lib/rails/application.rb', line 511

def secret_key_base
  config.secret_key_base
end

#server(&blk) ⇒ Object

Sends any server called in the instance of a new application up to the server method defined in Rails::Railtie.



389
390
391
 
# File 'railties/lib/rails/application.rb', line 389

def server(&blk)
  self.class.server(&blk)
end

#to_app ⇒ Object

:nodoc:



634
635
636
 
# File 'railties/lib/rails/application.rb', line 634

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.



460
461
462
463
464
465
466
467
468
 
# File 'railties/lib/rails/application.rb', line 460

def watchable_args # :nodoc:
  files, dirs = config.watchable_files.dup, config.watchable_dirs.dup

  Rails.autoloaders.main.dirs.each do |path|
    dirs[path] = [:rb]
  end

  [files, dirs]
end