Merge

Gemfile

@@ -31,3 +31,5 @@ if ENV['CI']
     gem "test-unit", ">= 2.0.5"
   end
 end
+
+disable_system_gems
\ No newline at end of file

actionmailer/lib/action_mailer/rails.rb

+require "action_mailer"
+
+module ActionMailer
+  class Plugin < Rails::Plugin
+    plugin_name :action_mailer
+
+    initializer "action_mailer.set_configs" do |app|
+      app.config.action_mailer.each do |k,v|
+        ActionMailer::Base.send "#{k}=", v
+      end
+    end
+
+    # TODO: ActionController::Base.logger should delegate to its own config.logger
+    initializer "action_mailer.logger" do
+      ActionMailer::Base.logger ||= Rails.logger
+    end
+
+    initializer "action_mailer.view_paths" do |app|
+      # TODO: this should be combined with the logic for default config.action_mailer.view_paths
+      view_path = ActionView::PathSet.type_cast(app.config.view_path, app.config.cache_classes)
+      ActionMailer::Base.template_root = view_path if ActionMailer::Base.view_paths.blank?
+    end
+  end
+end
\ No newline at end of file

actionpack/lib/action_controller/notifications.rb

-require 'active_support/notifications'
-
-ActiveSupport::Notifications.subscribe(/(read|write|cache|expire|exist)_(fragment|page)\??/) do |*args|
-  event = ActiveSupport::Notifications::Event.new(*args)
-
-  if logger = ActionController::Base.logger
-    human_name = event.name.to_s.humanize
-    logger.info("#{human_name} (%.1fms)" % event.duration)
-  end
-end

actionpack/lib/action_controller/rails.rb

+module ActionController
+  class Plugin < Rails::Plugin
+    plugin_name :action_controller
+
+    initializer "action_controller.set_configs" do |app|
+      app.config.action_controller.each do |k,v|
+        ActionController::Base.send "#{k}=", v
+      end
+    end
+
+    # TODO: ActionController::Base.logger should delegate to its own config.logger
+    initializer "action_controller.logger" do
+      ActionController::Base.logger ||= Rails.logger
+    end
+
+    # Routing must be initialized after plugins to allow the former to extend the routes
+    # ---
+    # 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).
+    initializer "action_controller.initialize_routing" do |app|
+      app.route_configuration_files << app.config.routes_configuration_file
+      app.route_configuration_files << app.config.builtin_routes_configuration_file
+      app.reload_routes!
+    end
+
+    # Include middleware to serve up static assets
+    initializer "action_controller.initialize_static_server" do |app|
+      if app.config.serve_static_assets
+        app.config.middleware.use(ActionDispatch::Static, Rails.public_path)
+      end
+    end
+
+    initializer "action_controller.initialize_middleware_stack" do |app|
+      middleware = app.config.middleware
+      middleware.use(::Rack::Lock, :if => lambda { ActionController::Base.allow_concurrency })
+      middleware.use(::Rack::Runtime)
+      middleware.use(ActionDispatch::ShowExceptions, lambda { ActionController::Base.consider_all_requests_local })
+      middleware.use(ActionDispatch::Callbacks, lambda { ActionController::Dispatcher.prepare_each_request })
+      middleware.use(lambda { ActionController::Base.session_store }, lambda { ActionController::Base.session_options })
+      middleware.use(ActionDispatch::ParamsParser)
+      middleware.use(::Rack::MethodOverride)
+      middleware.use(::Rack::Head)
+      middleware.use(ActionDispatch::StringCoercion)
+    end
+
+    initializer "action_controller.initialize_framework_caches" do
+      ActionController::Base.cache_store ||= RAILS_CACHE
+    end
+
+    # Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
+    # (but only for those frameworks that are to be loaded). If the framework's
+    # paths have already been set, it is not changed, otherwise it is
+    # set to use Configuration#view_path.
+    initializer "action_controller.initialize_framework_views" do |app|
+      # TODO: this should be combined with the logic for default config.action_controller.view_paths
+      view_path = ActionView::PathSet.type_cast(app.config.view_path, app.config.cache_classes)
+      ActionController::Base.view_paths = view_path if ActionController::Base.view_paths.blank?
+    end
+
+    initializer "action_controller.initialize_metal" do |app|
+      Rails::Rack::Metal.requested_metals = app.config.metals
+
+      app.config.middleware.insert_before(:"ActionDispatch::ParamsParser",
+        Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
+    end
+
+    # # Prepare dispatcher callbacks and run 'prepare' callbacks
+    initializer "action_controller.prepare_dispatcher" do |app|
+      # TODO: This used to say unless defined?(Dispatcher). Find out why and fix.
+      require 'rails/dispatcher'
+
+      Dispatcher.define_dispatcher_callbacks(app.config.cache_classes)
+
+      unless app.config.cache_classes
+        # Setup dev mode route reloading
+        routes_last_modified = app.routes_changed_at
+        reload_routes = lambda do
+          unless app.routes_changed_at == routes_last_modified
+            routes_last_modified = app.routes_changed_at
+            app.reload_routes!
+          end
+        end
+        ActionDispatch::Callbacks.before_dispatch { |callbacks| reload_routes.call }
+      end
+    end
+
+    initializer "action_controller.notifications" do |app|
+      require 'active_support/notifications'
+
+      ActiveSupport::Notifications.subscribe(/(read|write|cache|expire|exist)_(fragment|page)\??/) do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+
+        if logger = ActionController::Base.logger
+          human_name = event.name.to_s.humanize
+          logger.info("#{human_name} (%.1fms)" % event.duration)
+        end
+      end
+    end
+
+  end
+end
\ No newline at end of file

actionpack/lib/action_dispatch/routing/route_set.rb

@@ -273,7 +273,7 @@ def controller_namespaces
         # TODO: Move this into Railties
         if defined?(Rails.application)
           # Find namespaces in controllers/ directory
-          Rails.application.configuration.controller_paths.each do |load_path|
+          Rails.application.config.controller_paths.each do |load_path|
             load_path = File.expand_path(load_path)
             Dir["#{load_path}/**/*_controller.rb"].collect do |path|
               namespaces << File.dirname(path).sub(/#{load_path}\/?/, '')

actionpack/lib/action_view.rb

@@ -32,7 +32,6 @@ module ActionView
   extend ActiveSupport::Autoload
 
   eager_autoload do
-    autoload :Base
     autoload :Context
     autoload :Template
     autoload :Helpers
@@ -56,5 +55,6 @@ module ActionView
 end
 
 require 'action_view/erb/util'
+require 'action_view/base'
 
 I18n.load_path << "#{File.dirname(__FILE__)}/action_view/locale/en.yml"

actionpack/test/dispatch/response_test.rb

@@ -178,7 +178,7 @@ def app
     @app = lambda { |env|
       [200,
         {'ETag' => '"202cb962ac59075b964b07152d234b70"',
-          'Cache-Control' => 'public'}, 'Hello']
+          'Cache-Control' => 'public'}, ['Hello']]
     }
 
     get '/'
@@ -217,7 +217,7 @@ def app
     @app = lambda { |env|
       [200,
         {'Content-Type' => 'application/xml; charset=utf-16'},
-        'Hello']
+        ['Hello']]
     }
 
     get '/'

actionpack/test/dispatch/routing_test.rb

@@ -109,8 +109,9 @@ def self.matches?(request)
       scope ':access_token', :constraints => { :access_token => /\w{5,5}/ } do
         resources :rooms
       end
-      
+
       match '/info' => 'projects#info', :as => 'info'
+
       root :to => 'projects#index'
     end
   end
@@ -478,6 +479,14 @@ def test_index
     end
   end
 
+  def test_index
+    with_test_routes do
+      assert_equal '/info', info_path
+      get '/info'
+      assert_equal 'projects#info', @response.body
+    end
+  end
+
   private
     def with_test_routes
       real_routes, temp_routes = ActionController::Routing::Routes, Routes

activerecord/lib/active_record/notifications.rb

-require 'active_support/notifications'
-
-ActiveSupport::Notifications.subscribe("sql") do |name, before, after, result, instrumenter_id, payload|
-  ActiveRecord::Base.connection.log_info(payload[:sql], name, after - before)
-end

activerecord/lib/active_record/rails.rb

+# For now, action_controller must always be present with
+# rails, so let's make sure that it gets required before
+# here. This is needed for correctly setting up the middleware.
+# In the future, this might become an optional require.
+require "action_controller/rails"
+
+module ActiveRecord
+  class Plugin < Rails::Plugin
+    plugin_name :active_record
+
+    initializer "active_record.set_configs" do |app|
+      app.config.active_record.each do |k,v|
+        ActiveRecord::Base.send "#{k}=", v
+      end
+    end
+
+    # This sets the database configuration from Configuration#database_configuration
+    # and then establishes the connection.
+    initializer "active_record.initialize_database" do |app|
+      ActiveRecord::Base.configurations = app.config.database_configuration
+      ActiveRecord::Base.establish_connection
+    end
+
+    initializer "active_record.initialize_timezone" do
+      ActiveRecord::Base.time_zone_aware_attributes = true
+      ActiveRecord::Base.default_timezone = :utc
+    end
+
+    # Setup database middleware after initializers have run
+    initializer "active_record.initialize_database_middleware" do |app|
+      middleware = app.config.middleware
+      if middleware.include?(ActiveRecord::SessionStore)
+        middleware.insert_before ActiveRecord::SessionStore, ActiveRecord::ConnectionAdapters::ConnectionManagement
+        middleware.insert_before ActiveRecord::SessionStore, ActiveRecord::QueryCache
+      else
+        middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
+        middleware.use ActiveRecord::QueryCache
+      end
+    end
+
+    initializer "active_record.load_observers" do
+      ActiveRecord::Base.instantiate_observers
+    end
+
+    # TODO: ActiveRecord::Base.logger should delegate to its own config.logger
+    initializer "active_record.logger" do
+      ActiveRecord::Base.logger ||= Rails.logger
+    end
+
+    initializer "active_record.notifications" do
+      require 'active_support/notifications'
+
+      ActiveSupport::Notifications.subscribe("sql") do |name, before, after, result, instrumenter_id, payload|
+        ActiveRecord::Base.connection.log_info(payload[:sql], name, after - before)
+      end
+    end
+
+  end
+end
\ No newline at end of file

activeresource/test/cases/base/schema_test.rb

 require 'abstract_unit'
+require 'active_support/core_ext/hash/conversions'
 require "fixtures/person"
 require "fixtures/street_address"
 

activesupport/lib/active_support/json/encoding.rb

@@ -65,6 +65,15 @@ def check_for_circular_references(value)
 
 
       ESCAPED_CHARS = {
+        "\x00" => '\u0000', "\x01" => '\u0001', "\x02" => '\u0002',
+        "\x03" => '\u0003', "\x04" => '\u0004', "\x05" => '\u0005',
+        "\x06" => '\u0006', "\x07" => '\u0007', "\x0B" => '\u000B',
+        "\x0E" => '\u000E', "\x0F" => '\u000F', "\x10" => '\u0010',
+        "\x11" => '\u0011', "\x12" => '\u0012', "\x13" => '\u0013',
+        "\x14" => '\u0014', "\x15" => '\u0015', "\x16" => '\u0016',
+        "\x17" => '\u0017', "\x18" => '\u0018', "\x19" => '\u0019',
+        "\x1A" => '\u001A', "\x1B" => '\u001B', "\x1C" => '\u001C',
+        "\x1D" => '\u001D', "\x1E" => '\u001E', "\x1F" => '\u001F',
         "\010" =>  '\b',
         "\f"   =>  '\f',
         "\n"   =>  '\n',
@@ -86,9 +95,9 @@ class << self
         def escape_html_entities_in_json=(value)
           self.escape_regex = \
             if @escape_html_entities_in_json = value
-              /[\010\f\n\r\t"\\><&]/
+              /[\x00-\x1F"\\><&]/
             else
-              /[\010\f\n\r\t"\\]/
+              /[\x00-\x1F"\\]/
             end
         end
 

activesupport/test/json/encoding_test.rb

@@ -23,7 +23,9 @@ def as_json(options)
 
   StringTests   = [[ 'this is the <string>',     %("this is the \\u003Cstring\\u003E")],
                    [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
-                   [ 'http://test.host/posts/1', %("http://test.host/posts/1")]]
+                   [ 'http://test.host/posts/1', %("http://test.host/posts/1")],
+                   [ "Control characters: \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f",
+                     %("Control characters: \\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000B\\f\\r\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F") ]]
 
   ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\",\"b\",\"c\"])          ],
                    [ [1, 'a', :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]

railties/builtin/routes.rb

 ActionController::Routing::Routes.draw do |map|
-  match '/rails/info/properties' => "rails::info#properties"
+  match '/rails/info/properties' => "rails/info#properties"
 end
\ No newline at end of file

railties/lib/rails.rb

-require "pathname"
-
-require 'active_support'
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/logger'
-require 'action_dispatch'
-
-require 'rails/initializable'
-require 'rails/application'
-require 'rails/plugin'
-require 'rails/railties_path'
-require 'rails/version'
-require 'rails/rack'
-require 'rails/paths'
-require 'rails/core'
-require 'rails/configuration'
-require 'rails/deprecation'
-require 'rails/initializer'
-require 'rails/ruby_version_check'
-
-# For Ruby 1.8, this initialization sets $KCODE to 'u' to enable the
-# multibyte safe operations. Plugin authors supporting other encodings
-# should override this behaviour and set the relevant +default_charset+
-# on ActionController::Base.
-#
-# For Ruby 1.9, UTF-8 is the default internal and external encoding.
-if RUBY_VERSION < '1.9'
-  $KCODE='u'
-else
-  Encoding.default_external = Encoding::UTF_8
-end
-
-RAILS_ENV = (ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development").dup unless defined?(RAILS_ENV)
+require "rails/core"
+
+%w(active_model active_record action_controller action_view action_mailer active_resource).each do |framework|
+  begin
+    require framework
+    require "#{framework}/rails"
+  rescue LoadError
+  end
+end
\ No newline at end of file

railties/lib/rails/application.rb

+require "fileutils"
+require 'active_support/core_ext/module/delegation'
+
 module Rails
   class Application
     include Initializable
 
     class << self
-      # Stub out App initialize
-      def initialize!
-        new
-      end
+      attr_writer :config
+      alias configure class_eval
+      delegate :initialize!, :load_tasks, :to => :instance
 
-      def new
-        @instance ||= begin
-          begin
-            require config.environment_path
-          rescue LoadError
-          end
-          super
-        end
+      private :new
+      def instance
+        @instance ||= new
       end
 
       def config
-        @config ||= begin
-          config = Configuration.new
-          Plugin.plugins.each { |p| config.merge(p.config) }
-          config
-        end
-      end
-
-      # TODO: change the plugin loader to use config
-      alias configuration config
-
-      def config=(config)
-        @config = config
-      end
-
-      def root
-        config.root
-      end
-
-      def load_tasks
-        require "rails/tasks"
-        Dir["#{root}/vendor/plugins/*/**/tasks/**/*.rake"].sort.each { |ext| load ext }
-        Dir["#{root}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
-        task :environment do
-          $rails_rake_task = true
-          initialize!
-        end
+        @config ||= Configuration.new(Plugin::Configuration.default)
       end
 
       def routes
         ActionController::Routing::Routes
       end
-
-      def call(env)
-        new.call(env)
-      end
     end
 
+    delegate :config, :routes, :to => :'self.class'
+    delegate :root, :middleware, :to => :config
     attr_reader :route_configuration_files
 
     def initialize
+      require_environment
       Rails.application ||= self
-
       @route_configuration_files = []
-
-      run_initializers(self)
-    end
-
-    def config
-      self.class.config
     end
 
-    class << self
-      alias configure class_eval
-    end
-
-    def root
-      config.root
-    end
-
-    alias configuration config
-
-    def middleware
-      config.middleware
+    def initialize!
+      run_initializers(self)
+      self
     end
 
-    def routes
-      ActionController::Routing::Routes
+    def require_environment
+      require config.environment_path
+    rescue LoadError
     end
 
     def routes_changed_at
@@ -114,16 +70,27 @@ def reload_routes!
       routes.disable_clear_and_finalize = false
     end
 
+    def load_tasks
+      require "rails/tasks"
+      Dir["#{root}/vendor/plugins/*/**/tasks/**/*.rake"].sort.each { |ext| load ext }
+      Dir["#{root}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+      task :environment do
+        $rails_rake_task = true
+        initialize!
+      end
+    end
+
     def initializers
       initializers = super
       plugins.each { |p| initializers += p.initializers }
       initializers
     end
 
+    # TODO: Fix this method
     def plugins
       @plugins ||= begin
         plugin_names = config.plugins || [:all]
-        Plugin.plugins.select { |p| plugin_names.include?(p.plugin_name) } +
+        Plugin.plugins.select { |p| plugin_names.include?(:all) || plugin_names.include?(p.plugin_name) } +
         Plugin::Vendored.all(config.plugins || [:all], config.paths.vendor.plugins)
       end
     end
@@ -133,6 +100,10 @@ def call(env)
       @app.call(env)
     end
 
+    initializer :load_all_active_support do
+      require "active_support/all" unless config.active_support.bare
+    end
+
     # Set the <tt>$LOAD_PATH</tt> based on the value of
     # Configuration#load_paths. Duplicates are removed.
     initializer :set_load_path do
@@ -140,14 +111,6 @@ def call(env)
       $LOAD_PATH.uniq!
     end
 
-    # Requires all frameworks specified by the Configuration#frameworks
-    # list. By default, all frameworks (Active Record, Active Support,
-    # Action Pack, Action Mailer, and Active Resource) are loaded.
-    initializer :require_frameworks do
-      require 'active_support/all' unless config.active_support.bare
-      config.frameworks.each { |framework| require(framework.to_s) }
-    end
-
     # Set the paths from which Rails will automatically load source files, and
     # the load_once paths.
     initializer :set_autoload_paths do
@@ -170,7 +133,7 @@ def call(env)
     # Create tmp directories
     initializer :ensure_tmp_directories_exist do
       %w(cache pids sessions sockets).each do |dir_to_make|
-        FileUtils.mkdir_p(File.join(config.root, 'tmp', dir_to_make))
+        FileUtils.mkdir_p(File.join(root, 'tmp', dir_to_make))
       end
     end
 
@@ -178,45 +141,7 @@ def call(env)
     # Used by Passenger to ensure everything's loaded before forking and
     # to avoid autoload race conditions in JRuby.
     initializer :preload_frameworks do
-      if config.preload_frameworks
-        config.frameworks.each do |framework|
-          # String#classify and #constantize aren't available yet.
-          toplevel = Object.const_get(framework.to_s.gsub(/(?:^|_)(.)/) { $1.upcase })
-          toplevel.load_all! if toplevel.respond_to?(:load_all!)
-        end
-      end
-    end
-
-    # This initialization routine does nothing unless <tt>:active_record</tt>
-    # is one of the frameworks to load (Configuration#frameworks). If it is,
-    # this sets the database configuration from Configuration#database_configuration
-    # and then establishes the connection.
-    initializer :initialize_database do
-      if config.frameworks.include?(:active_record)
-        ActiveRecord::Base.configurations = config.database_configuration
-        ActiveRecord::Base.establish_connection
-      end
-    end
-
-    # Include middleware to serve up static assets
-    initializer :initialize_static_server do
-      if config.frameworks.include?(:action_controller) && config.serve_static_assets
-        config.middleware.use(ActionDispatch::Static, Rails.public_path)
-      end
-    end
-
-    initializer :initialize_middleware_stack do
-      if config.frameworks.include?(:action_controller)
-        config.middleware.use(::Rack::Lock, :if => lambda { ActionController::Base.allow_concurrency })
-        config.middleware.use(::Rack::Runtime)
-        config.middleware.use(ActionDispatch::ShowExceptions, lambda { ActionController::Base.consider_all_requests_local })
-        config.middleware.use(ActionDispatch::Callbacks, lambda { ActionController::Dispatcher.prepare_each_request })
-        config.middleware.use(lambda { ActionController::Base.session_store }, lambda { ActionController::Base.session_options })
-        config.middleware.use(ActionDispatch::ParamsParser)
-        config.middleware.use(::Rack::MethodOverride)
-        config.middleware.use(::Rack::Head)
-        config.middleware.use(ActionDispatch::StringCoercion)
-      end
+      ActiveSupport::Autoload.eager_load! if config.preload_frameworks
     end
 
     initializer :initialize_cache do
@@ -230,12 +155,6 @@ def call(env)
       end
     end
 
-    initializer :initialize_framework_caches do
-      if config.frameworks.include?(:action_controller)
-        ActionController::Base.cache_store ||= RAILS_CACHE
-      end
-    end
-
     initializer :initialize_logger do
       # if the environment has explicitly defined a logger, use it
       next if Rails.logger
@@ -266,10 +185,6 @@ def call(env)
     # logger is already set, it is not changed, otherwise it is set to use
     # RAILS_DEFAULT_LOGGER.
     initializer :initialize_framework_logging do
-      for framework in ([ :active_record, :action_controller, :action_mailer ] & config.frameworks)
-        framework.to_s.camelize.constantize.const_get("Base").logger ||= Rails.logger
-      end
-
       ActiveSupport::Dependencies.logger ||= Rails.logger
       Rails.cache.logger ||= Rails.logger
     end
@@ -287,7 +202,7 @@ def call(env)
       require('active_support/whiny_nil') if config.whiny_nils
     end
 
-    # Sets the default value for Time.zone, and turns on ActiveRecord::Base#time_zone_aware_attributes.
+    # Sets the default value for Time.zone
     # If assigned value cannot be matched to a TimeZone, an exception will be raised.
     initializer :initialize_time_zone do
       if config.time_zone
@@ -301,11 +216,6 @@ def call(env)
         end
 
         Time.zone_default = zone_default
-
-        if config.frameworks.include?(:active_record)
-          ActiveRecord::Base.time_zone_aware_attributes = true
-          ActiveRecord::Base.default_timezone = :utc
-        end
       end
     end
 
@@ -321,118 +231,28 @@ def call(env)
       end
     end
 
-    # Initializes framework-specific settings for each of the loaded frameworks
-    # (Configuration#frameworks). The available settings map to the accessors
-    # on each of the corresponding Base classes.
-    initializer :initialize_framework_settings do
-      config.frameworks.each do |framework|
-        base_class = framework.to_s.camelize.constantize.const_get("Base")
-
-        config.send(framework).each do |setting, value|
-          base_class.send("#{setting}=", value)
-        end
-      end
-    end
-
-    # Sets +ActionController::Base#view_paths+ and +ActionMailer::Base#template_root+
-    # (but only for those frameworks that are to be loaded). If the framework's
-    # paths have already been set, it is not changed, otherwise it is
-    # set to use Configuration#view_path.
-    initializer :initialize_framework_views do
-      if config.frameworks.include?(:action_view)
-        view_path = ActionView::PathSet.type_cast(config.view_path, config.cache_classes)
-        ActionMailer::Base.template_root  = view_path if config.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
-        ActionController::Base.view_paths = view_path if config.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
-      end
-    end
-
-    initializer :initialize_metal do
-      # TODO: Make Rails and metal work without ActionController
-      if config.frameworks.include?(:action_controller)
-        Rails::Rack::Metal.requested_metals = config.metals
-
-        config.middleware.insert_before(
-          :"ActionDispatch::ParamsParser",
-          Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
-      end
-    end
-
     # # bail out if gems are missing - note that check_gem_dependencies will have
     # # already called abort() unless $gems_rake_task is set
     # return unless gems_dependencies_loaded
     initializer :load_application_initializers do
-      Dir["#{configuration.root}/config/initializers/**/*.rb"].sort.each do |initializer|
+      Dir["#{root}/config/initializers/**/*.rb"].sort.each do |initializer|
         load(initializer)
       end
     end
 
     # Fires the user-supplied after_initialize block (Configuration#after_initialize)
     initializer :after_initialize do
-      configuration.after_initialize_blocks.each do |block|
+      config.after_initialize_blocks.each do |block|
         block.call
       end
     end
 
-    # # Setup database middleware after initializers have run
-    initializer :initialize_database_middleware do
-      if configuration.frameworks.include?(:active_record)
-        if configuration.frameworks.include?(:action_controller) && ActionController::Base.session_store &&
-            ActionController::Base.session_store.name == 'ActiveRecord::SessionStore'
-          configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement
-          configuration.middleware.insert_before :"ActiveRecord::SessionStore", ActiveRecord::QueryCache
-        else
-          configuration.middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
-          configuration.middleware.use ActiveRecord::QueryCache
-        end
-      end
-    end
-
-    # TODO: Make a DSL way to limit an initializer to a particular framework
-
-    # # Prepare dispatcher callbacks and run 'prepare' callbacks
-    initializer :prepare_dispatcher do
-      next unless configuration.frameworks.include?(:action_controller)
-      require 'rails/dispatcher' unless defined?(::Dispatcher)
-      Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
-
-      unless configuration.cache_classes
-        # Setup dev mode route reloading
-        routes_last_modified = routes_changed_at
-        reload_routes = lambda do
-          unless routes_changed_at == routes_last_modified
-            routes_last_modified = routes_changed_at
-            reload_routes!
-          end
-        end
-        ActionDispatch::Callbacks.before_dispatch { |callbacks| reload_routes.call }
-      end
-    end
-
-    # Routing must be initialized after plugins to allow the former to extend the routes
-    # ---
-    # 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).
-    initializer :initialize_routing do
-      next unless configuration.frameworks.include?(:action_controller)
-      route_configuration_files << configuration.routes_configuration_file
-      route_configuration_files << configuration.builtin_routes_configuration_file
-      reload_routes!
-    end
-    #
-    # # Observers are loaded after plugins in case Observers or observed models are modified by plugins.
-    initializer :load_observers do
-      if configuration.frameworks.include?(:active_record)
-        ActiveRecord::Base.instantiate_observers
-      end
-    end
-
     # Eager load application classes
     initializer :load_application_classes do
       next if $rails_rake_task
 
-      if configuration.cache_classes
-        configuration.eager_load_paths.each do |load_path|
+      if config.cache_classes
+        config.eager_load_paths.each do |load_path|
           matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
           Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
             require_dependency file.sub(matcher, '\1')
@@ -443,7 +263,7 @@ def call(env)
 
     # Disable dependency loading during request cycle
     initializer :disable_dependency_loading do
-      if configuration.cache_classes && !configuration.dependency_loading
+      if config.cache_classes && !config.dependency_loading
         ActiveSupport::Dependencies.unhook!
       end
     end

railties/lib/rails/commands/server.rb

@@ -41,9 +41,9 @@ def self.start(app)
       new(app).start
     end
 
-    def initialize(app_const)
+    def initialize(app)
       super() # Call Rack::Server#initialize without passing any options to use.
-      @app_const = app_const
+      @app = app
     end
 
     def start
@@ -69,7 +69,7 @@ def middleware
     end
 
     def log_path
-      "#{File.expand_path(@app_const.root)}/log/#{options[:environment]}.log"
+      "#{File.expand_path(@app.root)}/log/#{options[:environment]}.log"
     end
 
     def default_options
@@ -77,10 +77,10 @@ def default_options
         :Port        => 3000,
         :Host        => "0.0.0.0",
         :environment => (ENV['RAILS_ENV'] || "development").dup,
-        :rack_file   => "#{@app_const.root}/config.ru",
+        :rack_file   => "#{@app.root}/config.ru",
         :daemonize   => false,
         :debugger    => false,
-        :pid         => "#{@app_const.root}/tmp/pids/server.pid",
+        :pid         => "#{@app.root}/tmp/pids/server.pid",
         :AccessLog   => []
       }
     end

railties/lib/rails/configuration.rb

@@ -5,22 +5,26 @@ module Rails
   # configuration class while this bit is being cleaned up.
   class Plugin::Configuration
 
-    def initialize
-      @options = Hash.new { |h,k| h[k] = ActiveSupport::OrderedOptions.new }
+    def self.default
+      @default ||= new
     end
 
-    def middleware
-      @middleware ||= ActionDispatch::MiddlewareStack.new
+    attr_reader :middleware
+
+    def initialize(base = nil)
+      if base
+        @options    = base.options.dup
+        @middleware = base.middleware.dup
+      else
+        @options    = Hash.new { |h,k| h[k] = ActiveSupport::OrderedOptions.new }
+        @middleware = ActionDispatch::MiddlewareStack.new
+      end
     end
 
     def respond_to?(name)
       super || name.to_s =~ config_key_regexp
     end
 
-    def merge(config)
-      @options = config.options.merge(@options)
-    end
-
   protected
 
     attr_reader :options
@@ -41,8 +45,7 @@ def config_key_regexp
     end
 
     def config_keys
-      ([ :active_support, :active_record, :action_controller,
-         :action_view, :action_mailer, :active_resource ] +
+      ([ :active_support, :action_view, :action_mailer, :active_resource ] +
         Plugin.plugin_names).map { |n| n.to_s }.uniq
     end
   end
@@ -60,7 +63,7 @@ class Configuration < Plugin::Configuration
                 :log_level, :log_path, :paths, :routes_configuration_file,
                 :view_path
 
-    def initialize
+    def initialize(base = nil)
       super
       @load_once_paths              = []
       @after_initialize_blocks      = []

railties/lib/rails/core.rb

+require "pathname"
+
+require 'active_support'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/logger'
+require 'action_dispatch'
+
+require 'rails/initializable'
+require 'rails/application'
+require 'rails/plugin'
+require 'rails/railties_path'
+require 'rails/version'
+require 'rails/rack'
+require 'rails/paths'
+require 'rails/core'
+require 'rails/configuration'
+require 'rails/deprecation'
+require 'rails/initializer'
+require 'rails/ruby_version_check'
+
+# For Ruby 1.8, this initialization sets $KCODE to 'u' to enable the
+# multibyte safe operations. Plugin authors supporting other encodings
+# should override this behaviour and set the relevant +default_charset+
+# on ActionController::Base.
+#
+# For Ruby 1.9, UTF-8 is the default internal and external encoding.
+if RUBY_VERSION < '1.9'
+  $KCODE='u'
+else
+  Encoding.default_external = Encoding::UTF_8
+end
+
+RAILS_ENV = (ENV["RAILS_ENV"] || ENV["RACK_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

railties/lib/rails/generators/rails/app/templates/config.ru

@@ -2,4 +2,4 @@
 require ::File.expand_path('../config/environment',  __FILE__)
 
 # Dispatch the request
-run <%= app_const%>
+run <%= app_const %>.instance

railties/lib/rails/generators/rails/app/templates/script/console.tt

 require File.expand_path('../../config/application',  __FILE__)
 require 'rails/commands/console'
-Rails::Console.start(<%= app_const %>)
+Rails::Console.start(<%= app_const %>.instance)

railties/lib/rails/generators/rails/app/templates/script/dbconsole.tt

 require File.expand_path('../../config/application',  __FILE__)
 require 'rails/commands/dbconsole'
-Rails::DBConsole.start(<%= app_const %>)
\ No newline at end of file
+Rails::DBConsole.start(<%= app_const %>.instance)

railties/lib/rails/generators/rails/app/templates/script/server.tt

 require File.expand_path('../../config/application',  __FILE__)
 require 'rails/commands/server'
-Rails::Server.start(<%= app_const %>)
+Rails::Server.start(<%= app_const %>.instance)

railties/lib/rails/initializable.rb

@@ -93,6 +93,7 @@ def initializers_for(scope = :global)
       end
 
       def initializer(name, opts = {}, &blk)
+        raise ArgumentError, "A block must be passed when defining an initializer" unless blk
         @initializers ||= []
         @initializers << Initializer.new(name, nil, opts, &blk)
       end

railties/lib/rails/plugin.rb

@@ -2,8 +2,10 @@ module Rails
   class Plugin
     include Initializable
 
-    def self.plugin_name
-      @plugin_name || name.demodulize.underscore
+    def self.plugin_name(plugin_name = nil)
+      @plugin_name ||= name.demodulize.underscore
+      @plugin_name = plugin_name if plugin_name
+      @plugin_name
     end
 
     def self.inherited(klass)
@@ -20,7 +22,7 @@ def self.plugin_names
     end
 
     def self.config
-      @config ||= Configuration.new
+      Configuration.default
     end
 
     class Vendored < Plugin

railties/test/application/configuration_test.rb

@@ -4,7 +4,16 @@ module ApplicationTests
   class InitializerTest < Test::Unit::TestCase
     include ActiveSupport::Testing::Isolation
 
+    def new_app
+      File.expand_path("#{app_path}/../new_app")
+    end
+
+    def copy_app
+      FileUtils.cp_r(app_path, new_app)
+    end
+
     def setup
+      FileUtils.rm_rf(new_app) if File.directory?(new_app)
       build_app
       boot_rails
     end
@@ -15,42 +24,42 @@ def setup
     end
 
     test "the application root can be set" do
-      FileUtils.mkdir_p("#{app_path}/hello")
+      copy_app
       add_to_config <<-RUBY
-        config.frameworks = []
-        config.root = '#{app_path}/hello'
+        config.root = '#{new_app}'
       RUBY
-      require "#{app_path}/config/environment"
-      assert_equal Pathname.new("#{app_path}/hello"), Rails.application.root
-    end
 
-    test "the application root is detected as where config.ru is located" do
-      add_to_config <<-RUBY
-        config.frameworks = []
-      RUBY
-      FileUtils.mv "#{app_path}/config.ru", "#{app_path}/config/config.ru"
+      use_frameworks []
+
       require "#{app_path}/config/environment"
-      assert_equal Pathname.new("#{app_path}/config"), Rails.application.root
+      assert_equal Pathname.new(new_app), Rails.application.root
     end
 
     test "the application root is Dir.pwd if there is no config.ru" do
       File.delete("#{app_path}/config.ru")
-      add_to_config <<-RUBY
-        config.frameworks = []
-      RUBY
 
-      Dir.chdir("#{app_path}/app") do
+      use_frameworks []
+
+      Dir.chdir("#{app_path}") do
         require "#{app_path}/config/environment"
-        assert_equal Pathname.new("#{app_path}/app"), Rails.application.root
+        assert_equal Pathname.new("#{app_path}"), Rails.application.root
       end
     end
 
+    test "if there's no config.active_support.bare, all of ActiveSupport is required" do
+      use_frameworks []
+      require "#{app_path}/config/environment"
+      assert_nothing_raised { [1,2,3].rand }
+    end
+
     test "config.active_support.bare does not require all of ActiveSupport" do
-      add_to_config "config.frameworks = []; config.active_support.bare = true"
+      add_to_config "config.active_support.bare = true"
+
+      use_frameworks []
 
       Dir.chdir("#{app_path}/app") do
         require "#{app_path}/config/environment"
-        assert_raises(NoMethodError) { 1.day }
+        assert_raises(NoMethodError) { [1,2,3].rand }
       end
     end
 
@@ -60,7 +69,7 @@ def setup
       RUBY
 
       require "#{app_path}/config/application"
-      assert AppTemplate::Application.configuration.action_controller.allow_concurrency
+      assert AppTemplate::Application.config.action_controller.allow_concurrency
     end
 
     test "the application can be marked as threadsafe when there are no frameworks" do

railties/test/application/generators_test.rb

@@ -7,8 +7,6 @@ class GeneratorsTest < Test::Unit::TestCase
     def setup
       build_app
       boot_rails
-      require "rails"
-      require "rails/generators"
     end
 
     def app_const
@@ -16,6 +14,8 @@ def app_const
     end
 
     def with_config
+      require "rails"
+      require "rails/generators"
       yield app_const.config
     end
 
@@ -46,14 +46,15 @@ def with_config
     end
 
     test "generators aliases and options on initialization" do
-      application = with_config do |c|
-        c.frameworks = []
-        c.generators.rails :aliases => { :test_framework => "-w" }
-        c.generators.orm :datamapper
-        c.generators.test_framework :rspec
-      end
+      add_to_config <<-RUBY
+        config.generators.rails :aliases => { :test_framework => "-w" }
+        config.generators.orm :datamapper
+        config.generators.test_framework :rspec
+      RUBY
+
+      require "#{app_path}/config/environment"
       # Initialize the application
-      app_const.initialize!
+      require "rails/generators"
       Rails::Generators.configure!
 
       assert_equal :rspec, Rails::Generators.options[:rails][:test_framework]
@@ -61,12 +62,13 @@ def with_config
     end
 
     test "generators no color on initialization" do
-      with_config do |c|
-        c.frameworks = []
-        c.generators.colorize_logging = false
-      end
+      add_to_config <<-RUBY
+        config.generators.colorize_logging = false
+      RUBY
+
       # Initialize the application
-      app_const.initialize!
+      require "#{app_path}/config/environment"
+      require "rails/generators"
       Rails::Generators.configure!
 
       assert_equal Thor::Base.shell, Thor::Shell::Basic

railties/test/application/initializer_test.rb

@@ -19,19 +19,6 @@ def setup
       assert $:.include?("#{app_path}/app/models")
     end
 
-    test "adding an unknown framework raises an error" do
-      add_to_config <<-RUBY
-        config.root = "#{app_path}"
-        config.frameworks << :action_foo
-      RUBY
-
-      require "active_support/core_ext/load_error"
-
-      assert_raises MissingSourceFile do
-        require "#{app_path}/config/environment"
-      end
-    end
-
     test "eager loading loads parent classes before children" do
       app_file "lib/zoo.rb", <<-ZOO
         class Zoo ; include ReptileHouse ; end
@@ -148,21 +135,9 @@ module Zoo::ReptileHouse ; end
       assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
     end
 
-    test "database middleware doesn't initialize when activerecord is not in frameworks" do
-      add_to_config <<-RUBY
-        config.root = "#{app_path}"
-        config.frameworks = []
-      RUBY
-      require "#{app_path}/config/environment"
-
-      assert_equal [], Rails.application.config.middleware
-    end
-
     test "database middleware initializes when session store is active record" do
-      add_to_config <<-RUBY
-        config.root = "#{app_path}"
-        config.action_controller.session_store = :active_record_store
-      RUBY
+      add_to_config "config.action_controller.session_store = :active_record_store"
+
       require "#{app_path}/config/environment"
 
       expects = [ActiveRecord::ConnectionAdapters::ConnectionManagement, ActiveRecord::QueryCache, ActiveRecord::SessionStore]
@@ -170,35 +145,28 @@ module Zoo::ReptileHouse ; end
       assert_equal expects, middleware & expects
     end
 
-    test "ensure database middleware doesn't use action_controller on initializing" do
+    test "Rails.root should be a Pathname" do
       add_to_config <<-RUBY
         config.root = "#{app_path}"
-        config.frameworks -= [:action_controller]
-        config.action_controller.session_store = :active_record_store
       RUBY
       require "#{app_path}/config/environment"
-
-      assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
+      assert_instance_of Pathname, Rails.root
     end
+  end
 
-    # Pathview test
-    test "load view paths doesn't perform anything when action_view not in frameworks" do
-      add_to_config <<-RUBY
-        config.root = "#{app_path}"
-        config.frameworks -= [:action_view]
-      RUBY
-      require "#{app_path}/config/environment"
+  class InitializerCustomFrameworkExtensionsTest < Test::Unit::TestCase
+    include ActiveSupport::Testing::Isolation
 
-      assert_equal nil, ActionMailer::Base.template_root
-      assert_equal [], ActionController::Base.view_paths
+    def setup
+      build_app
+      boot_rails
     end
 
-    test "Rails.root should be a Pathname" do
-      add_to_config <<-RUBY
-        config.root = "#{app_path}"
-      RUBY
+    test "database middleware doesn't initialize when activerecord is not in frameworks" do
+      use_frameworks []
       require "#{app_path}/config/environment"
-      assert_instance_of Pathname, Rails.root
+
+      assert !defined?(ActiveRecord)
     end
   end
 end
\ No newline at end of file

railties/test/application/load_test.rb

 require "isolation/abstract_unit"
-# require "rails"
-# require 'action_dispatch'
 
 module ApplicationTests
   class LoadTest < Test::Unit::TestCase
@@ -22,8 +20,10 @@ def setup
     end
 
     test "config.ru can be racked up" do
-      @app = rackup
-      assert_welcome get("/")
+      Dir.chdir app_path do
+        @app = rackup
+        assert_welcome get("/")
+      end
     end
 
     test "Rails.application is available after config.ru has been racked up" do

railties/test/application/routing_test.rb

 require 'isolation/abstract_unit'
-require 'rack/test'
 
 module ApplicationTests
   class RoutingTest < Test::Unit::TestCase
     include ActiveSupport::Testing::Isolation
-    include Rack::Test::Methods
 
     def setup
       build_app
+      boot_rails
+      require 'rack/test'
+      extend Rack::Test::Methods
     end
 
     def app
       @app ||= begin
-        boot_rails
         require "#{app_path}/config/environment"
 
         Rails.application
       end
     end
 
+    test "rails/info/properties" do
+      get "/rails/info/properties"
+      assert_equal 200, last_response.status
+    end
+
     test "simple controller" do
       controller :foo, <<-RUBY
         class FooController < ActionController::Base
@@ -166,6 +171,8 @@ def baz
         end
       RUBY
 
+      sleep 0.1
+
       get '/foo'
       assert_equal 'baz', last_response.body
     end

railties/test/initializable_test.rb

@@ -150,6 +150,16 @@ class Basic < ActiveSupport::TestCase
       Word.run_initializers
       assert_equal "bird", $word
     end
+
+    test "creating initializer without a block raises an error" do
+      assert_raise(ArgumentError) do
+        Class.new do
+          include Rails::Initializable
+
+          initializer :foo
+        end
+      end
+    end
   end
 
   class BeforeAfter < ActiveSupport::TestCase

railties/test/isolation/abstract_unit.rb

@@ -153,6 +153,14 @@ def controller(name, contents)
       app_file("app/controllers/#{name}_controller.rb", contents)
     end
 
+    def use_frameworks(arr)
+      to_remove =  [:actionmailer,
+                    :activemodel,
+                    :activerecord,
+                    :activeresource] - arr
+      $:.reject! {|path| path =~ %r'/(#{to_remove.join('|')})/' }
+    end
+
     def boot_rails
       root = File.expand_path('../../../..', __FILE__)
       begin

railties/test/plugins/framework_extension_test.rb

+require "isolation/abstract_unit"
+
+module PluginsTest
+  class FrameworkExtensionTest < Test::Unit::TestCase
+    def setup
+      build_app
+      boot_rails
+    end
+
+    test "active_record extensions are applied to ActiveRecord" do
+      add_to_config "config.active_record.table_name_prefix = 'tbl_'"
+
+      require "#{app_path}/config/environment"
+
+      assert_equal 'tbl_', ActiveRecord::Base.table_name_prefix
+    end
+  end
+end
\ No newline at end of file