class Rails::Application

def add_lib_to_load_path! #:nodoc:
  path = config.root.join('lib').to_s
  $LOAD_PATH.unshift(path) if File.exists?(path)
end

def app
  @app ||= begin
    config.middleware = config.middleware.merge_into(default_middleware_stack)
    config.middleware.build(routes)
  end
end

def call(env)
  app.call(env.reverse_merge!(env_defaults))
end

def configure(&block)
  class_eval(&block)
end

def default_middleware_stack
  ActionDispatch::MiddlewareStack.new.tap do |middleware|
    middleware.use ::ActionDispatch::Static, paths.public.to_a.first if config.serve_static_assets
    middleware.use ::Rack::Lock if !config.allow_concurrency
    middleware.use ::Rack::Runtime
    middleware.use ::Rails::Rack::Logger
    middleware.use ::ActionDispatch::ShowExceptions, config.consider_all_requests_local if config.action_dispatch.show_exceptions
    middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
    middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
    middleware.use ::ActionDispatch::Callbacks, !config.cache_classes
    middleware.use ::ActionDispatch::Cookies
    if config.session_store
      middleware.use config.session_store, config.session_options
      middleware.use ::ActionDispatch::Flash
    end
    middleware.use ::ActionDispatch::ParamsParser
    middleware.use ::Rack::MethodOverride
    middleware.use ::ActionDispatch::Head
    middleware.use ::ActionDispatch::BestStandardsSupport, config.action_dispatch.best_standards_support if config.action_dispatch.best_standards_support
  end
end

def eager_load! #:nodoc:
  railties.all(&:eager_load!)
  super
end

def env_defaults
  @env_defaults ||= {
    "action_dispatch.parameter_filter" => config.filter_parameters,
    "action_dispatch.secret_token" => config.secret_token
  }
end

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

def initialize!
  run_initializers(self)
  self
end

def initialize_console(sandbox=false)
  require "rails/console/app"
  require "rails/console/sandbox" if sandbox
  require "rails/console/helpers"
end

def initialize_generators
  require "rails/generators"
end

def initialize_tasks
  require "rails/tasks"
  task :environment do
    $rails_rake_task = true
    require_environment!
  end
end

def initializers
  initializers = Bootstrap.initializers_for(self)
  railties.all { |r| initializers += r.initializers }
  initializers += super
  initializers += Finisher.initializers_for(self)
  initializers
end

def instance
  if self == Rails::Application
    if Rails.application
      ActiveSupport::Deprecation.warn "Calling a method in Rails::Application is deprecated, " <<
        "please call it directly in your application constant #{Rails.application.class.name}.", caller
    end
    Rails.application
  else
    @@instance ||= new
  end
end

def load_console(sandbox=false)
  initialize_console(sandbox)
  railties.all { |r| r.load_console }
  super()
  self
end

def load_generators
  initialize_generators
  railties.all { |r| r.load_generators }
  super
  self
end

def load_tasks
  initialize_tasks
  railties.all { |r| r.load_tasks }
  super
  self
end

def method_missing(*args, &block)
  instance.send(*args, &block)
end

def railties
  @railties ||= Railties.new(config)
end

def reload_routes!
  _routes = self.routes
  _routes.disable_clear_and_finalize = true
  _routes.clear!
  routes_reloader.paths.each { |path| load(path) }
  ActiveSupport.on_load(:action_controller) { _routes.finalize! }
ensure
  _routes.disable_clear_and_finalize = false
end

def require_environment! #:nodoc:
  environment = paths.config.environment.to_a.first
  require environment if environment
end

def respond_to?(*args)
  super || instance.respond_to?(*args)
end

def routes
  @routes ||= ActionDispatch::Routing::RouteSet.new
end

def routes_reloader
  @routes_reloader ||= ActiveSupport::FileUpdateChecker.new([]){ reload_routes! }
end