Skip to content

Commit

Permalink
Separate Rails module methods, the config object, and the initializer…
Browse files Browse the repository at this point in the history 
… into separate files.
  • Loading branch information
Yehuda Katz + Carl Lerche committed Jun 23, 2009
1 parent ce9d9fd commit 3aad4d7
Show file tree
Hide file tree
Showing 3 changed files with 338 additions and 334 deletions.
336 changes: 2 additions & 334 deletions railties/lib/initializer.rb
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,344 +5,12 @@
require 'rails/version'
require 'rails/gem_dependency'
require 'rails/rack'
require 'rails/core'
require 'rails/configuration'

RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)

module Rails
# Needs to be duplicated from Active Support since its needed before Active
# Support is available. Here both Options and Hash are namespaced to prevent
# conflicts with other implementations AND with the classes residing in Active Support.
# ---
# TODO: w0t?
class << self
# The Configuration instance used to configure the Rails environment
def configuration
@@configuration
end

def configuration=(configuration)
@@configuration = configuration
end

def initialized?
@initialized || false
end

def initialized=(initialized)
@initialized ||= initialized
end

def logger
if defined?(RAILS_DEFAULT_LOGGER)
RAILS_DEFAULT_LOGGER
else
nil
end
end

def backtrace_cleaner
@@backtrace_cleaner ||= begin
# Relies on ActiveSupport, so we have to lazy load to postpone definition until AS has been loaded
require 'rails/backtrace_cleaner'
Rails::BacktraceCleaner.new
end
end

def root
Pathname.new(RAILS_ROOT) if defined?(RAILS_ROOT)
end

def env
@_env ||= ActiveSupport::StringInquirer.new(RAILS_ENV)
end

def cache
RAILS_CACHE
end

def version
VERSION::STRING
end

def public_path
@@public_path ||= self.root ? File.join(self.root, "public") : "public"
end

def public_path=(path)
@@public_path = path
end
end

class OrderedOptions < Array #:nodoc:
def []=(key, value)
key = key.to_sym

if pair = find_pair(key)
pair.pop
pair << value
else
self << [key, value]
end
end

def [](key)
pair = find_pair(key.to_sym)
pair ? pair.last : nil
end

def method_missing(name, *args)
if name.to_s =~ /(.*)=$/
self[$1.to_sym] = args.first
else
self[name]
end
end

private
def find_pair(key)
self.each { |i| return i if i.first == key }
return false
end
end

class Configuration
attr_accessor :cache_classes, :load_paths, :eager_load_paths, :framework_paths,
:load_once_paths, :gems_dependencies_loaded, :after_initialize_blocks,
:frameworks, :framework_root_path, :root_path, :plugin_paths, :plugins,
:plugin_loader, :plugin_locators, :gems, :loaded_plugins, :reload_plugins,
:i18n, :gems, :whiny_nils, :consider_all_requests_local,
:action_controller, :active_record, :action_view, :active_support,
:action_mailer, :active_resource,
:log_path, :log_level, :logger, :preload_frameworks,
:database_configuration_file, :cache_store, :time_zone,
:view_path, :metals, :controller_paths, :routes_configuration_file,
:eager_load_paths, :dependency_loading

def initialize
set_root_path!

@framework_paths = []
@load_once_paths = []
@after_initialize_blocks = []
@loaded_plugins = []
@dependency_loading = true
@eager_load_paths = default_eager_load_paths
@load_paths = default_load_paths
@plugin_paths = default_plugin_paths
@frameworks = default_frameworks
@plugin_loader = default_plugin_loader
@plugin_locators = default_plugin_locators
@gems = default_gems
@i18n = default_i18n
@log_path = default_log_path
@log_level = default_log_level
@cache_store = default_cache_store
@view_path = default_view_path
@controller_paths = default_controller_paths
@routes_configuration_file = default_routes_configuration_file
@database_configuration_file = default_database_configuration_file

for framework in default_frameworks
self.send("#{framework}=", Rails::OrderedOptions.new)
end
self.active_support = Rails::OrderedOptions.new
end

def after_initialize(&blk)
@after_initialize_blocks << blk if blk
end

def set_root_path!
raise 'RAILS_ROOT is not set' unless defined?(RAILS_ROOT)
raise 'RAILS_ROOT is not a directory' unless File.directory?(RAILS_ROOT)

self.root_path =
# Pathname is incompatible with Windows, but Windows doesn't have
# real symlinks so File.expand_path is safe.
if RUBY_PLATFORM =~ /(:?mswin|mingw)/
File.expand_path(RAILS_ROOT)

# Otherwise use Pathname#realpath which respects symlinks.
else
Pathname.new(RAILS_ROOT).realpath.to_s
end

RAILS_ROOT.replace self.root_path
end

# Enable threaded mode. Allows concurrent requests to controller actions and
# multiple database connections. Also disables automatic dependency loading
# after boot, and disables reloading code on every request, as these are
# fundamentally incompatible with thread safety.
def threadsafe!
self.preload_frameworks = true
self.cache_classes = true
self.dependency_loading = false
self.action_controller.allow_concurrency = true
self
end

def framework_paths
paths = %w(railties railties/lib activesupport/lib)
paths << 'actionpack/lib' if frameworks.include?(:action_controller) || frameworks.include?(:action_view)

[:active_record, :action_mailer, :active_resource, :action_web_service].each do |framework|
paths << "#{framework.to_s.gsub('_', '')}/lib" if frameworks.include?(framework)
end

paths.map { |dir| "#{framework_root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
end

def framework_root_path
defined?(::RAILS_FRAMEWORK_ROOT) ? ::RAILS_FRAMEWORK_ROOT : "#{root_path}/vendor/rails"
end

# TODO: Fix this when there is an application object
def middleware
require 'action_controller'
ActionController::Dispatcher.middleware
end

# Loads and returns the contents of the #database_configuration_file. The
# contents of the file are processed via ERB before being sent through
# YAML::load.
def database_configuration
require 'erb'
YAML::load(ERB.new(IO.read(database_configuration_file)).result)
end

def default_routes_configuration_file
File.join(root_path, 'config', 'routes.rb')
end

def default_controller_paths
paths = [File.join(root_path, 'app', 'controllers')]
paths.concat builtin_directories
paths
end

def default_cache_store
if File.exist?("#{root_path}/tmp/cache/")
[ :file_store, "#{root_path}/tmp/cache/" ]
else
:memory_store
end
end

def default_database_configuration_file
File.join(root_path, 'config', 'database.yml')
end

def default_view_path
File.join(root_path, 'app', 'views')
end

def default_eager_load_paths
%w(
app/metal
app/models
app/controllers
app/helpers
).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
end

def default_load_paths
paths = []

# Add the old mock paths only if the directories exists
paths.concat(Dir["#{root_path}/test/mocks/#{RAILS_ENV}"]) if File.exists?("#{root_path}/test/mocks/#{RAILS_ENV}")

# Add the app's controller directory
paths.concat(Dir["#{root_path}/app/controllers/"])

# Followed by the standard includes.
paths.concat %w(
app
app/metal
app/models
app/controllers
app/helpers
app/services
lib
vendor
).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }

paths.concat builtin_directories
end

def builtin_directories
# Include builtins only in the development environment.
(RAILS_ENV == 'development') ? Dir["#{RAILTIES_PATH}/builtin/*/"] : []
end

def default_log_path
File.join(root_path, 'log', "#{RAILS_ENV}.log")
end

def default_log_level
RAILS_ENV == 'production' ? :info : :debug
end

def default_frameworks
[ :active_record, :action_controller, :action_view, :action_mailer, :active_resource ]
end

def default_plugin_paths
["#{root_path}/vendor/plugins"]
end

def default_plugin_loader
require 'rails/plugin/loader'
Plugin::Loader
end

def default_plugin_locators
require 'rails/plugin/locator'
locators = []
locators << Plugin::GemLocator if defined? Gem
locators << Plugin::FileSystemLocator
end

def default_i18n
i18n = Rails::OrderedOptions.new
i18n.load_path = []

if File.exist?(File.join(RAILS_ROOT, 'config', 'locales'))
i18n.load_path << Dir[File.join(RAILS_ROOT, 'config', 'locales', '*.{rb,yml}')]
i18n.load_path.flatten!
end

i18n
end

# Adds a single Gem dependency to the rails application. By default, it will require
# the library with the same name as the gem. Use :lib to specify a different name.
#
# # gem 'aws-s3', '>= 0.4.0'
# # require 'aws/s3'
# config.gem 'aws-s3', :lib => 'aws/s3', :version => '>= 0.4.0', \
# :source => "http://code.whytheluckystiff.net"
#
# To require a library be installed, but not attempt to load it, pass :lib => false
#
# config.gem 'qrp', :version => '0.4.1', :lib => false
def gem(name, options = {})
@gems << Rails::GemDependency.new(name, options)
end

def default_gems
[]
end

def environment_path
"#{root_path}/config/environments/#{RAILS_ENV}.rb"
end

def reload_plugins?
@reload_plugins
end
end

class Initializer
class Error < StandardError ; end

Expand Down
Loading

0 comments on commit 3aad4d7

Please sign in to comment.