class Rails::Application

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

Attributes

assets[RW]

reloaders[R]

sandbox[RW]

sandbox?[RW]

Public Class Methods

new() click to toggle source

Calls superclass method

# File lib/rails/application.rb, line 77
def initialize
  super
  @initialized = false
  @reloaders   = []
end

Public Instance Methods

call(env) click to toggle source

Calls superclass method

# File lib/rails/application.rb, line 229
def call(env)
  env["ORIGINAL_FULLPATH"] = build_original_fullpath(env)
  super(env)
end

env_config() click to toggle source

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.

Calls superclass method

# File 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

inherited(base) click to toggle source

Calls superclass method

# File 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

load_console(app=self) click to toggle source

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

Calls superclass method

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

load_runner(app=self) click to toggle source

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

Calls superclass method

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

load_tasks(app=self) click to toggle source

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

Calls superclass method

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

reload_routes!() click to toggle source

Reload application routes regardless if they changed or not.

# File lib/rails/application.rb, line 107
def reload_routes!
  routes_reloader.reload!
end

to_app() click to toggle source

# File lib/rails/application.rb, line 221
def to_app
  self
end

watchable_args() click to toggle source

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

# File 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

Protected Instance Methods

build_original_fullpath(env) click to toggle source

# File 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() click to toggle source

# File 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?() click to toggle source

# File lib/rails/application.rb, line 238
def reload_dependencies?
  config.reload_classes_only_on_change != true || reloaders.map(&:updated?).any?
end