require 'logger' RAILS_ENV = ENV['RAILS_ENV'] || 'development' module Rails # The Initializer is responsible for processing the Rails configuration, such as setting the $LOAD_PATH, requiring the # right frameworks, initializing logging, and more. It can be run either as a single command that'll just use the # default configuration, like this: # # Rails::Initializer.run # # But normally it's more interesting to pass in a custom configuration through the block running: # # Rails::Initializer.run do |config| # config.frameworks -= [ :action_web_service ] # end # # This will use the default configuration options from Rails::Configuration, but allow for overwriting on select areas. class Initializer attr_reader :configuration def self.run(command = :process, configuration = Configuration.new) yield configuration if block_given? new(configuration).send(command) end def initialize(configuration) @configuration = configuration end def process set_load_path require_frameworks require_environment initialize_database initialize_logger initialize_framework_logging initialize_framework_views initialize_routing initialize_session_settings initialize_session_store initialize_fragment_store end def set_load_path configuration.load_paths.reverse.each { |dir| $LOAD_PATH.unshift(dir) if File.directory?(dir) } $LOAD_PATH.uniq! end def require_frameworks configuration.frameworks.each { |framework| require(framework.to_s) } end def require_environment require_dependency(configuration.environment_file) end def initialize_database return unless configuration.frameworks.include?(:active_record) ActiveRecord::Base.configurations = configuration.database_configuration ActiveRecord::Base.establish_connection end def initialize_logger # if the environment has explicitly defined a logger, use it return if defined?(RAILS_DEFAULT_LOGGER) begin logger = Logger.new(configuration.log_path) logger.level = Logger.const_get(configuration.log_level.to_s.upcase) rescue StandardError logger = Logger.new(STDERR) logger.level = Logger::WARN logger.warn( "Rails Error: Unable to access log file. Please ensure that #{configuration.log_path} exists and is chmod 0666. " + "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed." ) end silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger } end def initialize_framework_logging # TODO: Only do logging for frameworks loaded [ActiveRecord, ActionController, ActionMailer].each { |mod| mod::Base.logger ||= RAILS_DEFAULT_LOGGER } end def initialize_framework_views # TODO: Only do view setting for frameworks loaded [ActionController, ActionMailer].each { |mod| mod::Base.template_root ||= configuration.view_path } end def initialize_routing return unless configuration.frameworks.include?(:action_controller) ActionController::Routing::Routes.reload Object.const_set "Controllers", Dependencies::LoadingModule.root(*configuration.controller_paths) end def initialize_session_settings return unless configuration.frameworks.include?(:action_controller) ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.merge!(configuration.session_options) end def initialize_session_store return if !configuration.frameworks.include?(:action_controller) || configuration.session_store.nil? if configuration.session_store.is_a?(Symbol) ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager] = CGI::Session.const_get(configuration.session_store.to_s.camelize) else ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager] = configuration.session_store end end def initialize_fragment_store return if !configuration.frameworks.include?(:action_controller) || configuration.fragment_store.nil? configuration.fragment_store = [ configuration.fragment_store ].flatten store = ActionController::Caching::Fragments.const_get(configuration.fragment_store.first.to_s.camelize) if parameters = configuration.fragment_store[1..-1] ActionController::Base.fragment_cache_store = store.new(*parameters) else ActionController::Base.fragment_cache_store = store.new end end end # The Configuration class holds all the parameters for the Initializer and ships with defaults that suites most # Rails applications. But it's possible to overwrite everything. Usually, you'll create an Configuration file implicitly # through the block running on the Initializer, but it's also possible to create the Configuration instance in advance and # pass it in like this: # # config = Rails::Configuration.new # Rails::Initializer.run(:process, config) class Configuration attr_accessor :frameworks, :load_paths, :log_level, :log_path, :database_configuration_file, :view_path, :controller_paths attr_accessor :session_options, :session_store, :fragment_store def initialize self.frameworks = default_frameworks self.load_paths = default_load_paths self.log_path = default_log_path self.log_level = default_log_level self.view_path = default_view_path self.controller_paths = default_controller_paths self.session_options = default_session_options self.database_configuration_file = default_database_configuration_file end def database_configuration YAML::load(ERB.new((IO.read(database_configuration_file))).result) end def environment_file "environments/#{environment}" end def environment ::RAILS_ENV end private def default_frameworks [ :active_support, :active_record, :action_controller, :action_mailer, :action_web_service ] end def default_load_paths paths = ["#{RAILS_ROOT}/test/mocks/#{environment}"] # Then model subdirectories. # TODO: Don't include .rb models as load paths paths.concat(Dir["#{RAILS_ROOT}/app/models/[_a-z]*"]) paths.concat(Dir["#{RAILS_ROOT}/components/[_a-z]*"]) # Followed by the standard includes. # TODO: Don't include dirs for frameworks that are not used paths.concat %w( app app/models app/controllers app/helpers app/apis components config lib vendor vendor/rails/railties vendor/rails/railties/lib vendor/rails/actionpack/lib vendor/rails/activesupport/lib vendor/rails/activerecord/lib vendor/rails/actionmailer/lib vendor/rails/actionwebservice/lib ).map { |dir| "#{RAILS_ROOT}/#{dir}" }.select { |dir| File.directory?(dir) } end def default_log_path File.join(RAILS_ROOT, 'log', "#{environment}.log") end def default_log_level environment == 'production' ? :info : :debug end def default_database_configuration_file File.join(RAILS_ROOT, 'config', 'database.yml') end def default_view_path File.join(RAILS_ROOT, 'app', 'views') end def default_controller_paths [ File.join(RAILS_ROOT, 'app', 'controllers'), File.join(RAILS_ROOT, 'components') ] end def default_session_options {} end end end