rails 2.0.5 → 2.1.0

data/lib/commands/servers/webrick.rb

@@ -61,6 +61,6 @@ require 'webrick_server'
 
 OPTIONS['working_directory'] = File.expand_path(RAILS_ROOT)
 
-puts "=> Rails application started on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
+puts "=> Rails #{Rails.version} application started on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
 puts "=> Ctrl-C to shutdown server; call with --help for options" if OPTIONS[:server_type] == WEBrick::SimpleServer
 DispatchServlet.dispatch(OPTIONS)

data/lib/console_app.rb

@@ -24,7 +24,7 @@ end
 def reload!
   puts "Reloading..."
   dispatcher = ActionController::Dispatcher.new($stdout)
-  dispatcher.cleanup_application(true)
-  dispatcher.prepare_application(true)
+  dispatcher.cleanup_application
+  dispatcher.reload_application
   true
 end

data/lib/dispatcher.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2007 David Heinemeier Hansson
+# Copyright (c) 2004-2008 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/fcgi_handler.rb

@@ -73,18 +73,20 @@ class RailsFCGIHandler
     def process_each_request(provider)
       cgi = nil
 
-      provider.each_cgi do |cgi|
-        process_request(cgi)
-
-        case when_ready
-          when :reload
-            reload!
-          when :restart
-            close_connection(cgi)
-            restart!
-          when :exit
-            close_connection(cgi)
-            break
+      catch :exit do
+        provider.each_cgi do |cgi|
+          process_request(cgi)
+
+          case when_ready
+            when :reload
+              reload!
+            when :restart
+              close_connection(cgi)
+              restart!
+            when :exit
+              close_connection(cgi)
+              throw :exit
+          end
         end
       end
     rescue SignalException => signal
@@ -93,7 +95,7 @@ class RailsFCGIHandler
     end
 
     def process_request(cgi)
-      @when_ready = nil
+      @processing, @when_ready = true, nil
       gc_countdown
 
       with_signal_handler 'USR1' do
@@ -105,6 +107,8 @@ class RailsFCGIHandler
           dispatcher_error error, 'unhandled dispatch error'
         end
       end
+    ensure
+      @processing = false
     end
 
     def logger
@@ -158,17 +162,29 @@ class RailsFCGIHandler
 
     def exit_handler(signal)
       dispatcher_log :info, "asked to stop ASAP"
-      @when_ready = :exit
+      if @processing
+        @when_ready = :exit
+      else
+        throw :exit
+      end
     end
 
     def reload_handler(signal)
       dispatcher_log :info, "asked to reload ASAP"
-      @when_ready = :reload
+      if @processing
+        @when_ready = :reload
+      else
+        reload!
+      end
     end
 
     def restart_handler(signal)
       dispatcher_log :info, "asked to restart ASAP"
-      @when_ready = :restart
+      if @processing
+        @when_ready = :restart
+      else
+        restart!
+      end
     end
 
     def restart!

data/lib/initializer.rb

@@ -7,11 +7,55 @@ require 'railties_path'
 require 'rails/version'
 require 'rails/plugin/locator'
 require 'rails/plugin/loader'
+require 'rails/gem_dependency'
 
 
 RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)
 
 module Rails
+  class << self
+    # The Configuration instance used to configure the Rails environment
+    def configuration
+      @@configuration
+    end
+  
+    def configuration=(configuration)
+      @@configuration = configuration
+    end
+  
+    def logger
+      RAILS_DEFAULT_LOGGER
+    end
+  
+    def root
+      if defined?(RAILS_ROOT)
+        RAILS_ROOT
+      else
+        nil
+      end
+    end
+  
+    def env
+      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
+  
   # 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
@@ -58,62 +102,60 @@ module Rails
     end
 
     # Sequentially step through all of the available initialization routines,
-    # in order:
-    #
-    # * #check_ruby_version
-    # * #set_load_path
-    # * #require_frameworks
-    # * #set_autoload_paths
-    # * add_plugin_load_paths
-    # * #load_environment
-    # * #initialize_encoding
-    # * #initialize_database
-    # * #initialize_logger
-    # * #initialize_framework_logging
-    # * #initialize_framework_views
-    # * #initialize_dependency_mechanism
-    # * #initialize_whiny_nils
-    # * #initialize_temporary_directories
-    # * #initialize_framework_settings
-    # * #add_support_load_paths
-    # * #load_plugins
-    # * #load_observers
-    # * #initialize_routing
-    # * #after_initialize
-    # * #load_application_initializers
+    # in order (view execution order in source).
     def process
+      Rails.configuration = configuration
+
       check_ruby_version
+      install_gem_spec_stubs
       set_load_path
       
       require_frameworks
       set_autoload_paths
+      add_gem_load_paths
       add_plugin_load_paths
       load_environment
 
       initialize_encoding
       initialize_database
+
+      initialize_cache
+      initialize_framework_caches
+
       initialize_logger
       initialize_framework_logging
+
       initialize_framework_views
       initialize_dependency_mechanism
       initialize_whiny_nils
-      initialize_temporary_directories
+      initialize_temporary_session_directory
+      initialize_time_zone
       initialize_framework_settings
 
       add_support_load_paths
 
+      load_gems
       load_plugins
 
-      # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
-      load_observers
-
-      # Routing must be initialized after plugins to allow the former to extend the routes
-      initialize_routing
+      # pick up any gems that plugins depend on
+      add_gem_load_paths
+      load_gems
+      check_gem_dependencies
+      
+      load_application_initializers
 
       # the framework is now fully initialized
       after_initialize
 
-      load_application_initializers
+      # Prepare dispatcher callbacks and run 'prepare' callbacks
+      prepare_dispatcher
+
+      # Routing must be initialized after plugins to allow the former to extend the routes
+      initialize_routing
+
+      # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
+      
+      load_observers
     end
 
     # Check for valid Ruby version
@@ -123,6 +165,30 @@ module Rails
       require 'ruby_version_check'
     end
 
+    # If Rails is vendored and RubyGems is available, install stub GemSpecs
+    # for Rails, Active Support, Active Record, Action Pack, Action Mailer, and
+    # Active Resource. This allows Gem plugins to depend on Rails even when
+    # the Gem version of Rails shouldn't be loaded.
+    def install_gem_spec_stubs
+      unless Rails.respond_to?(:vendor_rails?)
+        abort %{Your config/boot.rb is outdated: Run "rake rails:update".}
+      end
+
+      if Rails.vendor_rails?
+        begin; require "rubygems"; rescue LoadError; return; end
+
+        stubs = %w(rails activesupport activerecord actionpack actionmailer activeresource)
+        stubs.reject! { |s| Gem.loaded_specs.key?(s) }
+
+        stubs.each do |stub|
+          Gem.loaded_specs[stub] = Gem::Specification.new do |s|
+            s.name = stub
+            s.version = Rails::VERSION::STRING
+          end
+        end
+      end
+    end
+
     # Set the <tt>$LOAD_PATH</tt> based on the value of
     # Configuration#load_paths. Duplicates are removed.
     def set_load_path
@@ -150,8 +216,8 @@ module Rails
     end
 
     # Requires all frameworks specified by the Configuration#frameworks
-    # list. By default, all frameworks (ActiveRecord, ActiveSupport,
-    # ActionPack, ActionMailer, and ActiveResource) are loaded.
+    # list. By default, all frameworks (Active Record, Active Support,
+    # Action Pack, Action Mailer, and Active Resource) are loaded.
     def require_frameworks
       configuration.frameworks.each { |framework| require(framework.to_s) }
     rescue LoadError => e
@@ -169,6 +235,34 @@ module Rails
       plugin_loader.add_plugin_load_paths
     end
 
+    def add_gem_load_paths
+      unless @configuration.gems.empty?
+        require "rubygems"
+        @configuration.gems.each &:add_load_paths
+      end
+    end
+
+    def load_gems
+      @configuration.gems.each(&:load)
+    end
+
+    def check_gem_dependencies
+      unloaded_gems = @configuration.gems.reject { |g| g.loaded? }
+      if unloaded_gems.size > 0
+        @gems_dependencies_loaded = false
+        # don't print if the gems rake tasks are being run
+        unless $rails_gem_installer
+          puts %{These gems that this application depends on are missing:}
+          unloaded_gems.each do |gem|
+            puts " - #{gem.name}"
+          end
+          puts %{Run "rake gems:install" to install them.}
+        end
+      else
+        @gems_dependencies_loaded = true
+      end
+    end
+
     # Loads all plugins in <tt>config.plugin_paths</tt>.  <tt>plugin_paths</tt>
     # defaults to <tt>vendor/plugins</tt> but may also be set to a list of
     # paths, such as
@@ -212,7 +306,7 @@ module Rails
     end
 
     def load_observers
-      if configuration.frameworks.include?(:active_record)
+      if @gems_dependencies_loaded && configuration.frameworks.include?(:active_record)
         ActiveRecord::Base.instantiate_observers
       end
     end
@@ -239,7 +333,19 @@ module Rails
       end
     end
 
-    # If the +RAILS_DEFAULT_LOGGER+ constant is already set, this initialization
+    def initialize_cache
+      unless defined?(RAILS_CACHE)
+        silence_warnings { Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(configuration.cache_store) }
+      end
+    end
+
+    def initialize_framework_caches
+      if configuration.frameworks.include?(:action_controller)
+        ActionController::Base.cache_store ||= RAILS_CACHE
+      end
+    end
+
+    # If the RAILS_DEFAULT_LOGGER constant is already set, this initialization
     # routine does nothing. If the constant is not set, and Configuration#logger
     # is not +nil+, this also does nothing. Otherwise, a new logger instance
     # is created at Configuration#log_path, with a default log level of
@@ -255,8 +361,11 @@ module Rails
         begin
           logger = ActiveSupport::BufferedLogger.new(configuration.log_path)
           logger.level = ActiveSupport::BufferedLogger.const_get(configuration.log_level.to_s.upcase)
-          logger.auto_flushing = false if configuration.environment == "production"
-        rescue StandardError =>e
+          if configuration.environment == "production"
+            logger.auto_flushing = false
+            logger.set_non_blocking_io
+          end
+        rescue StandardError => e
           logger = ActiveSupport::BufferedLogger.new(STDERR)
           logger.level = ActiveSupport::BufferedLogger::WARN
           logger.warn(
@@ -269,14 +378,16 @@ module Rails
       silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }
     end
 
-    # Sets the logger for ActiveRecord, ActionController, and ActionMailer
+    # Sets the logger for Active Record, Action Controller, and Action Mailer
     # (but only for those frameworks that are to be loaded). If the framework's
     # logger is already set, it is not changed, otherwise it is set to use
-    # +RAILS_DEFAULT_LOGGER+.
+    # RAILS_DEFAULT_LOGGER.
     def initialize_framework_logging
       for framework in ([ :active_record, :action_controller, :action_mailer ] & configuration.frameworks)
         framework.to_s.camelize.constantize.const_get("Base").logger ||= RAILS_DEFAULT_LOGGER
       end
+      
+      RAILS_CACHE.logger ||= RAILS_DEFAULT_LOGGER
     end
 
     # Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
@@ -288,12 +399,13 @@ module Rails
       ActionController::Base.view_paths = [configuration.view_path] if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.empty?
     end
 
-    # If ActionController is not one of the loaded frameworks (Configuration#frameworks)
+    # If Action Controller is not one of the loaded frameworks (Configuration#frameworks)
     # this does nothing. Otherwise, it loads the routing definitions and sets up
     # loading module used to lazily load controllers (Configuration#controller_paths).
     def initialize_routing
       return unless configuration.frameworks.include?(:action_controller)
       ActionController::Routing.controller_paths = configuration.controller_paths
+      ActionController::Routing::Routes.configuration_file = configuration.routes_configuration_file
       ActionController::Routing::Routes.reload
     end
 
@@ -309,14 +421,25 @@ module Rails
       require('active_support/whiny_nil') if configuration.whiny_nils
     end
 
-    def initialize_temporary_directories
+    def initialize_temporary_session_directory
       if configuration.frameworks.include?(:action_controller)
         session_path = "#{configuration.root_path}/tmp/sessions/"
         ActionController::Base.session_options[:tmpdir] = File.exist?(session_path) ? session_path : Dir::tmpdir
+      end
+    end
 
-        cache_path = "#{configuration.root_path}/tmp/cache/"
-        if File.exist?(cache_path)
-          ActionController::Base.fragment_cache_store = :file_store, cache_path
+    # Sets the default value for Time.zone, and turns on ActiveRecord::Base#time_zone_aware_attributes.
+    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
+    def initialize_time_zone
+      if configuration.time_zone
+        zone_default = Time.send!(:get_zone, configuration.time_zone)
+        unless zone_default
+          raise %{Value assigned to config.time_zone not recognized. Run "rake -D time" for a list of tasks for finding appropriate time zone names.}
+        end
+        Time.zone_default = zone_default
+        if configuration.frameworks.include?(:active_record)
+          ActiveRecord::Base.time_zone_aware_attributes = true
+          ActiveRecord::Base.default_timezone = :utc
         end
       end
     end
@@ -332,21 +455,34 @@ module Rails
           base_class.send("#{setting}=", value)
         end
       end
+      configuration.active_support.each do |setting, value|
+        ActiveSupport.send("#{setting}=", value)
+      end
     end
 
     # Fires the user-supplied after_initialize block (Configuration#after_initialize)
     def after_initialize
-      configuration.after_initialize_blocks.each do |block|
-        block.call
+      if @gems_dependencies_loaded
+        configuration.after_initialize_blocks.each do |block|
+          block.call
+        end
       end
     end
 
     def load_application_initializers
-      Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
-        load(initializer)
+      if @gems_dependencies_loaded
+        Dir["#{configuration.root_path}/config/initializers/**/*.rb"].sort.each do |initializer|
+          load(initializer)
+        end
       end
     end
 
+    def prepare_dispatcher
+      require 'dispatcher' unless defined?(::Dispatcher)
+      Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
+      Dispatcher.new(RAILS_DEFAULT_LOGGER).send :run_callbacks, :prepare_dispatch
+    end
+
   end
 
   # The Configuration class holds all the parameters for the Initializer and
@@ -362,21 +498,24 @@ module Rails
     # The application's base directory.
     attr_reader :root_path
 
-    # A stub for setting options on ActionController::Base
+    # A stub for setting options on ActionController::Base.
     attr_accessor :action_controller
 
-    # A stub for setting options on ActionMailer::Base
+    # A stub for setting options on ActionMailer::Base.
     attr_accessor :action_mailer
 
-    # A stub for setting options on ActionView::Base
+    # A stub for setting options on ActionView::Base.
     attr_accessor :action_view
 
-    # A stub for setting options on ActiveRecord::Base
+    # A stub for setting options on ActiveRecord::Base.
     attr_accessor :active_record
 
-    # A stub for setting options on ActiveRecord::Base
+    # A stub for setting options on ActiveRecord::Base.
     attr_accessor :active_resource
 
+    # A stub for setting options on ActiveSupport.
+    attr_accessor :active_support
+
     # Whether or not classes should be cached (set to false if you want
     # application classes to be reloaded on each request)
     attr_accessor :cache_classes
@@ -388,6 +527,10 @@ module Rails
     # The path to the database configuration file to use. (Defaults to
     # <tt>config/database.yml</tt>.)
     attr_accessor :database_configuration_file
+    
+    # The path to the routes configuration file to use. (Defaults to
+    # <tt>config/routes.rb</tt>.)
+    attr_accessor :routes_configuration_file
 
     # The list of rails framework components that should be loaded. (Defaults
     # to <tt>:active_record</tt>, <tt>:action_controller</tt>,
@@ -418,6 +561,9 @@ module Rails
     # used directly.
     attr_accessor :logger
 
+    # The specific cache store to use. By default, the ActiveSupport::Cache::Store will be used.
+    attr_accessor :cache_store
+
     # The root of the application's views. (Defaults to <tt>app/views</tt>.)
     attr_accessor :view_path
 
@@ -448,6 +594,43 @@ module Rails
     # the implementation of Rails::Plugin::Loader for more details.
     attr_accessor :plugin_loader
     
+    # Enables or disables plugin reloading.  You can get around this setting per plugin.
+    # If <tt>reload_plugins?</tt> is false, add this to your plugin's <tt>init.rb</tt>
+    # to make it reloadable:
+    #
+    #   Dependencies.load_once_paths.delete lib_path
+    #
+    # If <tt>reload_plugins?</tt> is true, add this to your plugin's <tt>init.rb</tt>
+    # to only load it once:
+    #
+    #   Dependencies.load_once_paths << lib_path
+    #
+    attr_accessor :reload_plugins
+
+    # Returns true if plugin reloading is enabled.
+    def reload_plugins?
+      !!@reload_plugins
+    end
+
+    # An array of gems that this rails application depends on.  Rails will automatically load
+    # these gems during installation, and allow you to install any missing gems with:
+    #
+    #   rake gems:install
+    #
+    # You can add gems with the #gem method.
+    attr_accessor :gems
+
+    # Adds a single Gem dependency to the rails application.
+    #
+    #   # 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"
+    #
+    def gem(name, options = {})
+      @gems << Rails::GemDependency.new(name, options)
+    end
+    
     # Deprecated options:
     def breakpoint_server(_ = nil)
       $stderr.puts %(
@@ -458,6 +641,11 @@ module Rails
     end
     alias_method :breakpoint_server=, :breakpoint_server
 
+    # Sets the default +time_zone+.  Setting this will enable +time_zone+
+    # awareness for Active Record models and set the Active Record default
+    # timezone to <tt>:utc</tt>.
+    attr_accessor :time_zone
+
     # Create a new Configuration instance, initialized with the default
     # values.
     def initialize
@@ -477,10 +665,13 @@ module Rails
       self.plugin_locators              = default_plugin_locators
       self.plugin_loader                = default_plugin_loader
       self.database_configuration_file  = default_database_configuration_file
+      self.routes_configuration_file    = default_routes_configuration_file
+      self.gems                         = default_gems
 
       for framework in default_frameworks
         self.send("#{framework}=", Rails::OrderedOptions.new)
       end
+      self.active_support = Rails::OrderedOptions.new
     end
 
     # Set the root_path to RAILS_ROOT and canonicalize it.
@@ -510,14 +701,14 @@ module Rails
       YAML::load(ERB.new(IO.read(database_configuration_file)).result)
     end
 
-    # The path to the current environment's file (development.rb, etc.). By
+    # The path to the current environment's file (<tt>development.rb</tt>, etc.). By
     # default the file is at <tt>config/environments/#{environment}.rb</tt>.
     def environment_path
       "#{root_path}/config/environments/#{environment}.rb"
     end
 
     # Return the currently selected environment. By default, it returns the
-    # value of the +RAILS_ENV+ constant.
+    # value of the RAILS_ENV constant.
     def environment
       ::RAILS_ENV
     end
@@ -539,8 +730,10 @@ module Rails
     #
     # See Dispatcher#to_prepare.
     def to_prepare(&callback)
-      require 'dispatcher' unless defined?(::Dispatcher)
-      Dispatcher.to_prepare(&callback)
+      after_initialize do 
+        require 'dispatcher' unless defined?(::Dispatcher)
+        Dispatcher.to_prepare(&callback)
+      end
     end
 
     def builtin_directories
@@ -569,7 +762,10 @@ module Rails
       end
 
       def default_load_paths
-        paths = ["#{root_path}/test/mocks/#{environment}"]
+        paths = []
+        
+        # Add the old mock paths only if the directories exists
+        paths.concat(Dir["#{root_path}/test/mocks/#{environment}"]) if File.exists?("#{root_path}/test/mocks/#{environment}")
 
         # Add the app's controller directory
         paths.concat(Dir["#{root_path}/app/controllers/"])
@@ -610,6 +806,10 @@ module Rails
         File.join(root_path, 'config', 'database.yml')
       end
 
+      def default_routes_configuration_file
+        File.join(root_path, 'config', 'routes.rb')
+      end
+
       def default_view_path
         File.join(root_path, 'app', 'views')
       end
@@ -641,18 +841,32 @@ module Rails
       end
 
       def default_plugin_locators
-        [Plugin::FileSystemLocator]
+        locators = []
+        locators << Plugin::GemLocator if defined? Gem
+        locators << Plugin::FileSystemLocator
       end
 
       def default_plugin_loader
         Plugin::Loader
       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_gems
+        []
+      end
   end
 end
 
 # 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 ActiveSupport.
+# conflicts with other implementations AND with the classes residing in Active Support.
 class Rails::OrderedOptions < Array #:nodoc:
   def []=(key, value)
     key = key.to_sym