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, engines and plugin 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 “allow_concurrency”, “cache_classes”, “consider_all_requests_local”, “filter_parameters”, “logger”, “reload_plugins” 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.
9)  Custom Railtie#initializers added by railties, engines and applications are executed
10) Build the middleware stack and run to_prepare callbacks
11) Run config.before_eager_load and eager_load if cache classes is true
12) Run config.after_initialize callbacks
Namespace
Methods
B
C
D
E
I
L
N
R
T
W
Attributes
[RW] assets
[R] reloaders
[RW] sandbox
[RW] sandbox?
Class Public methods
inherited(base)
# File railties/lib/rails/application.rb, line 62
def inherited(base)
  raise "You cannot have more than one Rails::Application" if Rails.application
  super
  Rails.application = base.instance
  Rails.application.add_lib_to_load_path!
  ActiveSupport.run_load_hooks(:before_configuration, base.instance)
end
new()
# File railties/lib/rails/application.rb, line 77
def initialize
  super
  @initialized = false
  @reloaders   = []
end
Instance Public methods
call(env)
# File railties/lib/rails/application.rb, line 229
def call(env)
  env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
  super(env)
end
env_config()

Rails.application.env_config stores some of the Rails initial environment parameters. Currently stores:

* "action_dispatch.parameter_filter"         => config.filter_parameters,
* "action_dispatch.secret_token"             => config.secret_token,
* "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

These parameters will be used by middlewares and engines to configure themselves.

# File railties/lib/rails/application.rb, line 177
def env_config
  @app_env_config ||= super.merge({
    "action_dispatch.parameter_filter" => config.filter_parameters,
    "action_dispatch.secret_token" => config.secret_token,
    "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
  })
end
load_console(app=self)

Load the application console and invoke the registered hooks. Check Rails::Railtie.console for more info.

# File railties/lib/rails/application.rb, line 151
def load_console(app=self)
  initialize_console
  super
  self
end
load_runner(app=self)

Load the application runner and invoke the registered hooks. Check Rails::Railtie.runner for more info.

# File railties/lib/rails/application.rb, line 159
def load_runner(app=self)
  initialize_runner
  super
  self
end
load_tasks(app=self)

Load the application and its railties tasks and invoke the registered hooks. Check Rails::Railtie.rake_tasks for more info.

# File railties/lib/rails/application.rb, line 143
def load_tasks(app=self)
  initialize_tasks
  super
  self
end
reload_routes!()

Reload application routes regardless if they changed or not.

# File railties/lib/rails/application.rb, line 107
def reload_routes!
  routes_reloader.reload!
end
to_app()
# File railties/lib/rails/application.rb, line 221
def to_app
  self
end
watchable_args()

Returns an array of file paths appended with a hash of directories-extensions suitable for ActiveSupport::FileUpdateChecker API.

# File railties/lib/rails/application.rb, line 117
def watchable_args
  files = []
  files.concat config.watchable_files

  dirs = {}
  dirs.merge! config.watchable_dirs
  ActiveSupport::Dependencies.autoload_paths.each do |path|
    dirs[path.to_s] = [:rb]
  end

  [files, dirs]
end
Instance Protected methods
build_original_fullpath(env)
# File railties/lib/rails/application.rb, line 319
def build_original_fullpath(env)
  path_info    = env["PATH_INFO"]
  query_string = env["QUERY_STRING"]
  script_name  = env["SCRIPT_NAME"]

  if query_string.present?
    "#{script_name}#{path_info}?#{query_string}"
  else
    "#{script_name}#{path_info}"
  end
end
default_middleware_stack()
# File railties/lib/rails/application.rb, line 242
def default_middleware_stack
  require 'action_controller/railtie'

  ActionDispatch::MiddlewareStack.new.tap do |middleware|
    if rack_cache = config.action_controller.perform_caching && config.action_dispatch.rack_cache
      require "action_dispatch/http/rack_cache"
      middleware.use ::Rack::Cache, rack_cache
    end

    if config.force_ssl
      require "rack/ssl"
      middleware.use ::Rack::SSL, config.ssl_options
    end

    if config.serve_static_assets
      middleware.use ::ActionDispatch::Static, paths["public"].first, config.static_cache_control
    end

    middleware.use ::Rack::Lock unless config.allow_concurrency
    middleware.use ::Rack::Runtime
    middleware.use ::Rack::MethodOverride
    middleware.use ::ActionDispatch::RequestId
    middleware.use ::Rails::Rack::Logger, config.log_tags # must come after Rack::MethodOverride to properly log overridden methods
    middleware.use ::ActionDispatch::ShowExceptions, config.exceptions_app || ActionDispatch::PublicExceptions.new(Rails.public_path)
    middleware.use ::ActionDispatch::DebugExceptions
    middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies

    if config.action_dispatch.x_sendfile_header.present?
      middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
    end

    unless config.cache_classes
      app = self
      middleware.use ::ActionDispatch::Reloader, lambda { app.reload_dependencies? }
    end

    middleware.use ::ActionDispatch::Callbacks
    middleware.use ::ActionDispatch::Cookies

    if config.session_store
      if config.force_ssl && !config.session_options.key?(:secure)
        config.session_options[:secure] = true
      end
      middleware.use config.session_store, config.session_options
      middleware.use ::ActionDispatch::Flash
    end

    middleware.use ::ActionDispatch::ParamsParser
    middleware.use ::ActionDispatch::Head
    middleware.use ::Rack::ConditionalGet
    middleware.use ::Rack::ETag, "no-cache"

    if config.action_dispatch.best_standards_support
      middleware.use ::ActionDispatch::BestStandardsSupport, config.action_dispatch.best_standards_support
    end
  end
end
reload_dependencies?()
# File railties/lib/rails/application.rb, line 238
def reload_dependencies?
  config.reload_classes_only_on_change != true || reloaders.map(&:updated?).any?
end