Merge branch 'master' of github.com:rails/rails

Conflicts:
	railties/test/initializer/initialize_i18n_test.rb
	railties/test/initializer/path_test.rb

actionmailer/lib/action_mailer/base.rb

@@ -271,6 +271,8 @@ module ActionMailer #:nodoc:
     class_inheritable_accessor :view_paths
     self.view_paths = []
 
+    attr_internal :formats
+
     cattr_accessor :logger
 
     @@raise_delivery_errors = true
@@ -452,6 +454,7 @@ module ActionMailer #:nodoc:
     # remain uninitialized (useful when you only need to invoke the "receive"
     # method, for instance).
     def initialize(method_name=nil, *parameters) #:nodoc:
+      @_formats = []
       @_response_body = nil
       super()
       create!(method_name, *parameters) if method_name

actionpack/lib/abstract_controller/rendering.rb

@@ -126,7 +126,7 @@ module AbstractController
         options[:_template] = ActionView::Template::Text.new(options[:text], format_for_text)
       elsif options.key?(:inline)
         handler  = ActionView::Template.handler_class_for_extension(options[:type] || "erb")
-        template = ActionView::Template.new(options[:inline], "inline #{options[:inline].inspect}", handler, {})
+        template = ActionView::Template.new(options[:inline], "inline template", handler, {})
         options[:_template] = template
       elsif options.key?(:template)
         options[:_template_name] = options[:template]
@@ -194,8 +194,7 @@ module AbstractController
       #   otherwise, process the parameter into a ViewPathSet.
       def view_paths=(paths)
         clear_template_caches!
-        self._view_paths = paths.is_a?(ActionView::PathSet) ?
-                            paths : ActionView::Base.process_view_paths(paths)
+        self._view_paths = paths.is_a?(ActionView::PathSet) ? paths : ActionView::Base.process_view_paths(paths)
       end
     end
   end

actionpack/lib/action_view/render/rendering.rb

@@ -79,11 +79,11 @@ module ActionView
 
     def _render_inline(inline, layout, options)
       handler  = Template.handler_class_for_extension(options[:type] || "erb")
-      template = Template.new(options[:inline],
-        "inline #{options[:inline].inspect}", handler, {})
+      template = Template.new(options[:inline], "inline template", handler, {})
 
       locals  = options[:locals]
       content = template.render(self, locals)
+
       _render_text(content, layout, locals)
     end
 
@@ -91,6 +91,7 @@ module ActionView
       content = layout.render(self, locals) do |*name|
         _layout_for(*name) { content }
       end if layout
+
       content
     end
 
@@ -114,13 +115,7 @@ module ActionView
       end
 
       locals  = options[:locals] || {}
-
-      content = if partial
-        _render_partial_object(template, options)
-      else
-        template.render(self, locals)
-      end
-
+      content = partial ? _render_partial_object(template, options) : template.render(self, locals)
       @_content_for[:layout] = content
 
       if layout
@@ -128,6 +123,7 @@ module ActionView
         logger.info("Rendering template within #{layout.inspect}") if logger
         content = layout.render(self, locals) { |*name| _layout_for(*name) }
       end
+
       content
     end
   end

railties/lib/rails/application.rb

@@ -9,7 +9,13 @@ module Rails
       end
 
       def new
-        @instance ||= super
+        @instance ||= begin
+          begin
+            require config.environment_path
+          rescue LoadError
+          end
+          super
+        end
       end
 
       def config
@@ -64,6 +70,10 @@ module Rails
       self.class.config
     end
 
+    class << self
+      alias configure class_eval
+    end
+
     def root
       config.root
     end
@@ -123,23 +133,6 @@ module Rails
       @app.call(env)
     end
 
-
-    # Loads the environment specified by Configuration#environment_path, which
-    # is typically one of development, test, or production.
-    initializer :load_environment do
-      next unless File.file?(config.environment_path)
-
-      config = self.config
-
-      Kernel.class_eval do
-        meth = instance_method(:config) if Object.respond_to?(:config)
-        define_method(:config) { config }
-        require config.environment_path
-        remove_method :config
-        define_method(:config, &meth) if meth
-      end
-    end
-
     # Set the <tt>$LOAD_PATH</tt> based on the value of
     # Configuration#load_paths. Duplicates are removed.
     initializer :set_load_path do

railties/lib/rails/generators/rails/app/app_generator.rb

@@ -182,7 +182,7 @@ module Rails::Generators
       end
 
       def app_const
-        @app_const ||= app_name.classify
+        @app_const ||= "#{app_name.classify}::Application"
       end
 
       def app_secret

railties/lib/rails/generators/rails/app/templates/app/controllers/application_controller.rb

@@ -4,5 +4,5 @@
 class ApplicationController < ActionController::Base
   helper :all
   protect_from_forgery
-  filter_parameter_logging :password, :password_confirmation
+  filter_parameter_logging :password
 end

railties/lib/rails/generators/rails/app/templates/config/application.rb

@@ -1,6 +1,7 @@
 require File.expand_path('../boot', __FILE__)
 
-class <%= app_const %> < Rails::Application
+module <%= app_name.classify %>
+  class Application < Rails::Application
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration should go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded.
@@ -39,3 +40,4 @@ class <%= app_const %> < Rails::Application
     #   g.test_framework  :test_unit, :fixture => true
     # end
   end
+end

railties/lib/rails/generators/rails/app/templates/config/environments/development.rb

@@ -1,17 +0,0 @@
-# Settings specified here will take precedence over those in config/environment.rb
-
-# In the development environment your application's code is reloaded on
-# every request.  This slows down response time but is perfect for development
-# since you don't have to restart the webserver when you make code changes.
-config.cache_classes = false
-
-# Log error messages when you accidentally call methods on nil.
-config.whiny_nils = true
-
-# Show full error reports and disable caching
-config.action_controller.consider_all_requests_local = true
-config.action_view.debug_rjs                         = true
-config.action_controller.perform_caching             = false
-
-# Don't care if the mailer can't send
-config.action_mailer.raise_delivery_errors = false

railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt

@@ -0,0 +1,19 @@
+<%= app_const %>.configure do
+  # Settings specified here will take precedence over those in config/environment.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request.  This slows down response time but is perfect for development
+  # since you don't have to restart the webserver when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.action_controller.consider_all_requests_local = true
+  config.action_view.debug_rjs                         = true
+  config.action_controller.perform_caching             = false
+
+  # Don't care if the mailer can't send
+  config.action_mailer.raise_delivery_errors = false
+end

railties/lib/rails/generators/rails/app/templates/config/environments/production.rb

@@ -1,31 +0,0 @@
-# Settings specified here will take precedence over those in config/environment.rb
-
-# The production environment is meant for finished, "live" apps.
-# Code is not reloaded between requests
-config.cache_classes = true
-
-# Full error reports are disabled and caching is turned on
-config.action_controller.consider_all_requests_local = false
-config.action_controller.perform_caching             = true
-
-# See everything in the log (default is :info)
-# config.log_level = :debug
-
-# Use a different logger for distributed setups
-# config.logger = SyslogLogger.new
-
-# Use a different cache store in production
-# config.cache_store = :mem_cache_store
-
-# Disable Rails's static asset server
-# In production, Apache or nginx will already do this
-config.serve_static_assets = false
-
-# Enable serving of images, stylesheets, and javascripts from an asset server
-# config.action_controller.asset_host = "http://assets.example.com"
-
-# Disable delivery errors, bad email addresses will be ignored
-# config.action_mailer.raise_delivery_errors = false
-
-# Enable threaded mode
-# config.threadsafe!

railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt

@@ -0,0 +1,33 @@
+<%= app_const %>.configure do
+  # Settings specified here will take precedence over those in config/environment.rb
+
+  # The production environment is meant for finished, "live" apps.
+  # Code is not reloaded between requests
+  config.cache_classes = true
+
+  # Full error reports are disabled and caching is turned on
+  config.action_controller.consider_all_requests_local = false
+  config.action_controller.perform_caching             = true
+
+  # See everything in the log (default is :info)
+  # config.log_level = :debug
+
+  # Use a different logger for distributed setups
+  # config.logger = SyslogLogger.new
+
+  # Use a different cache store in production
+  # config.cache_store = :mem_cache_store
+
+  # Disable Rails's static asset server
+  # In production, Apache or nginx will already do this
+  config.serve_static_assets = false
+
+  # Enable serving of images, stylesheets, and javascripts from an asset server
+  # config.action_controller.asset_host = "http://assets.example.com"
+
+  # Disable delivery errors, bad email addresses will be ignored
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable threaded mode
+  # config.threadsafe!
+end

railties/lib/rails/generators/rails/app/templates/config/environments/test.rb

@@ -1,27 +0,0 @@
-# Settings specified here will take precedence over those in config/environment.rb
-
-# The test environment is used exclusively to run your application's
-# test suite.  You never need to work with it otherwise.  Remember that
-# your test database is "scratch space" for the test suite and is wiped
-# and recreated between test runs.  Don't rely on the data there!
-config.cache_classes = true
-
-# Log error messages when you accidentally call methods on nil.
-config.whiny_nils = true
-
-# Show full error reports and disable caching
-config.action_controller.consider_all_requests_local = true
-config.action_controller.perform_caching             = false
-
-# Disable request forgery protection in test environment
-config.action_controller.allow_forgery_protection    = false
-
-# Tell Action Mailer not to deliver emails to the real world.
-# The :test delivery method accumulates sent emails in the
-# ActionMailer::Base.deliveries array.
-config.action_mailer.delivery_method = :test
-
-# Use SQL instead of Active Record's schema dumper when creating the test database.
-# This is necessary if your schema can't be completely dumped by the schema dumper,
-# like if you have constraints or database-specific column types
-# config.active_record.schema_format = :sql

railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt

@@ -0,0 +1,29 @@
+<%= app_const %>.configure do
+  # Settings specified here will take precedence over those in config/environment.rb
+
+  # The test environment is used exclusively to run your application's
+  # test suite.  You never need to work with it otherwise.  Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs.  Don't rely on the data there!
+  config.cache_classes = true
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.action_controller.consider_all_requests_local = true
+  config.action_controller.perform_caching             = false
+
+  # Disable request forgery protection in test environment
+  config.action_controller.allow_forgery_protection    = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper,
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+end

railties/lib/rails/generators/rails/app/templates/config/routes.rb

@@ -48,7 +48,7 @@
 
   # You can have the root of your site routed with "root"
   # just remember to delete public/index.html.
-  # root :to => "welcome"
+  # root :to => "welcome#index"
 
   # See how all your routes lay out with "rake routes"
 

railties/test/application/configuration_test.rb

@@ -60,7 +60,7 @@ module ApplicationTests
       RUBY
 
       require "#{app_path}/config/application"
-      assert AppTemplate.configuration.action_controller.allow_concurrency
+      assert AppTemplate::Application.configuration.action_controller.allow_concurrency
     end
 
     test "the application can be marked as threadsafe when there are no frameworks" do

railties/test/application/initializer_test.rb

@@ -6,31 +6,29 @@ module ApplicationTests
 
     def setup
       build_app
-      FileUtils.rm_rf("#{app_path}/config/environments")
       boot_rails
       require "rails"
     end
 
     test "initializing an application adds the application paths to the load path" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
-      end
-      Object.const_set(:AppTemplate, Rails.application)
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
 
-      Rails.initialize!
+      require "#{app_path}/config/environment"
       assert $:.include?("#{app_path}/app/models")
     end
 
     test "adding an unknown framework raises an error" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.frameworks << :action_foo
-      end
+      RUBY
 
       require "active_support/core_ext/load_error"
 
       assert_raises MissingSourceFile do
-        Rails.initialize!
+        require "#{app_path}/config/environment"
       end
     end
 
@@ -42,13 +40,12 @@ module ApplicationTests
         module Zoo::ReptileHouse ; end
       ZOO
 
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.eager_load_paths = "#{app_path}/lib"
-      end
-      Object.const_set(:AppTemplate, Rails.application)
+      RUBY
 
-      Rails.initialize!
+      require "#{app_path}/config/environment"
 
       assert Zoo
     end
@@ -56,44 +53,43 @@ module ApplicationTests
     test "load environment with global" do
       app_file "config/environments/development.rb", "$initialize_test_set_from_env = 'success'"
       assert_nil $initialize_test_set_from_env
-      Rails::Initializer.run { |config| config.root = app_path }
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+      require "#{app_path}/config/environment"
       assert_equal "success", $initialize_test_set_from_env
     end
 
     test "action_controller load paths set only if action controller in use" do
       assert_nothing_raised NameError do
-        Rails::Initializer.run do |config|
-          config.root = app_path
+        add_to_config <<-RUBY
+          config.root = "#{app_path}"
           config.frameworks = []
-        end
-        Rails.initialize!
+        RUBY
+        require "#{app_path}/config/environment"
       end
     end
 
     test "after_initialize block works correctly" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.after_initialize { $test_after_initialize_block1 = "success" }
         config.after_initialize { $test_after_initialize_block2 = "congratulations" }
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal "success", $test_after_initialize_block1
       assert_equal "congratulations", $test_after_initialize_block2
     end
 
     test "after_initialize block works correctly when no block is passed" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.after_initialize { $test_after_initialize_block1 = "success" }
         config.after_initialize # don't pass a block, this is what we're testing!
         config.after_initialize { $test_after_initialize_block2 = "congratulations" }
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal "success", $test_after_initialize_block1
       assert_equal "congratulations", $test_after_initialize_block2
@@ -101,36 +97,40 @@ module ApplicationTests
 
     # i18n
     test "setting another default locale" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.i18n.default_locale = :de
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal :de, I18n.default_locale
     end
 
     test "no config locales dir present should return empty load path" do
       FileUtils.rm_rf "#{app_path}/config/locales"
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        assert_equal [], c.i18n.load_path
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+      require "#{app_path}/config/environment"
+
+      assert_equal [], Rails.application.config.i18n.load_path
     end
 
     test "config locales dir present should be added to load path" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        assert_equal ["#{app_path}/config/locales/en.yml"], c.i18n.load_path
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+
+      require "#{app_path}/config/environment"
+      assert_equal ["#{app_path}/config/locales/en.yml"],  Rails.application.config.i18n.load_path
     end
 
     test "config defaults should be added with config settings" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.i18n.load_path << "my/other/locale.yml"
-      end
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+        config.i18n.load_path << "my/other/locale.yml"
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal [
         "#{app_path}/config/locales/en.yml", "my/other/locale.yml"
@@ -139,31 +139,31 @@ module ApplicationTests
 
     # DB middleware
     test "database middleware doesn't initialize when session store is not active_record" do
-      Rails::Initializer.run do |config|
-        config.root = app_path
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
         config.action_controller.session_store = :cookie_store
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert !Rails.application.config.middleware.include?(ActiveRecord::SessionStore)
     end
 
     test "database middleware doesn't initialize when activerecord is not in frameworks" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.frameworks = []
-      end
+      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
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.action_controller.session_store = :active_record_store
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+        config.action_controller.session_store = :active_record_store
+      RUBY
+      require "#{app_path}/config/environment"
 
       expects = [ActiveRecord::ConnectionAdapters::ConnectionManagement, ActiveRecord::QueryCache, ActiveRecord::SessionStore]
       middleware = Rails.application.config.middleware.map { |m| m.klass }
@@ -171,35 +171,33 @@ module ApplicationTests
     end
 
     test "ensure database middleware doesn't use action_controller on initializing" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.frameworks -= [:action_controller]
-        c.action_controller.session_store = :active_record_store
-      end
-      Rails.initialize!
+      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)
     end
 
     # Pathview test
     test "load view paths doesn't perform anything when action_view not in frameworks" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.frameworks -= [:action_view]
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+        config.frameworks -= [:action_view]
+      RUBY
+      require "#{app_path}/config/environment"
 
       assert_equal nil, ActionMailer::Base.template_root
       assert_equal [], ActionController::Base.view_paths
     end
 
     test "Rails.root should be a Pathname" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+      RUBY
+      require "#{app_path}/config/environment"
       assert_instance_of Pathname, Rails.root
     end
   end

railties/test/application/routing_test.rb

@@ -29,7 +29,7 @@ module ApplicationTests
       RUBY
 
       app_file 'config/routes.rb', <<-RUBY
-        AppTemplate.routes.draw do |map|
+        AppTemplate::Application.routes.draw do |map|
           match ':controller(/:action)'
         end
       RUBY
@@ -56,7 +56,7 @@ module ApplicationTests
       RUBY
 
       app_file 'config/routes.rb', <<-RUBY
-        AppTemplate.routes.draw do |map|
+        AppTemplate::Application.routes.draw do |map|
           match ':controller(/:action)'
         end
       RUBY
@@ -88,7 +88,7 @@ module ApplicationTests
       RUBY
 
       app_file 'config/routes.rb', <<-RUBY
-        AppTemplate.routes.draw do |map|
+        AppTemplate::Application.routes.draw do |map|
           match ':controller(/:action)'
         end
       RUBY
@@ -110,7 +110,7 @@ module ApplicationTests
       RUBY
 
       app_file 'config/routes.rb', <<-RUBY
-        AppTemplate.routes.draw do |map|
+        AppTemplate::Application.routes.draw do |map|
           match 'foo', :to => 'foo#index'
         end
       RUBY
@@ -125,7 +125,7 @@ module ApplicationTests
         RUBY
 
         plugin.write 'config/routes.rb', <<-RUBY
-          AppTemplate.routes.draw do |map|
+          AppTemplate::Application.routes.draw do |map|
             match 'bar', :to => 'bar#index'
           end
         RUBY
@@ -152,7 +152,7 @@ module ApplicationTests
       RUBY
 
       app_file 'config/routes.rb', <<-RUBY
-        AppTemplate.routes.draw do |map|
+        AppTemplate::Application.routes.draw do |map|
           match 'foo', :to => 'foo#bar'
         end
       RUBY
@@ -161,7 +161,7 @@ module ApplicationTests
       assert_equal 'bar', last_response.body
 
       app_file 'config/routes.rb', <<-RUBY
-        AppTemplate.routes.draw do |map|
+        AppTemplate::Application.routes.draw do |map|
           match 'foo', :to => 'foo#baz'
         end
       RUBY

railties/test/initializer/initialize_i18n_test.rb

@@ -7,17 +7,15 @@ module InitializerTests
     def setup
       build_app
       boot_rails
-      require "rails"
     end
 
     # test_config_defaults_and_settings_should_be_added_to_i18n_defaults
     test "i18n config defaults and settings should be added to i18n defaults" do
-      Rails::Initializer.run do |c|
-        c.root = app_path
-        c.i18n.load_path << "my/other/locale.yml"
-      end
-      Object.const_set(:AppTemplate, Rails.application)
-      Rails.initialize!
+      add_to_config <<-RUBY
+        config.root = "#{app_path}"
+        config.i18n.load_path << "my/other/locale.yml"
+      RUBY
+      require "#{app_path}/config/environment"
 
       #{RAILS_FRAMEWORK_ROOT}/railties/test/fixtures/plugins/engines/engine/config/locales/en.yml
       assert_equal %W(

railties/test/initializer/path_test.rb

@@ -7,15 +7,14 @@ class PathsTest < Test::Unit::TestCase
     build_app
     boot_rails
     require "rails"
-    Rails::Initializer.run do |config|
-      config.root = app_path
+    add_to_config <<-RUBY
+      config.root = "#{app_path}"
       config.frameworks = [:action_controller, :action_view, :action_mailer, :active_record]
       config.after_initialize do
         ActionController::Base.session_store = nil
       end
-    end
-    Object.const_set(:AppTemplate, Rails.application)
-    Rails.initialize!
+    RUBY
+    require "#{app_path}/config/environment"
     @paths = Rails.application.config.paths
   end
 

railties/test/isolation/abstract_unit.rb

@@ -89,6 +89,13 @@ module TestHelpers
         end
       end
 
+      routes = File.read("#{app_path}/config/routes.rb")
+      if routes =~ /(\n\s*end\s*)\Z/
+        File.open("#{app_path}/config/routes.rb", 'w') do |f|
+          f.puts $` + "\nmatch ':controller(/:action(/:id))(.:format)'\n" + $1
+        end
+      end
+
       add_to_config 'config.action_controller.session = { :key => "_myapp_session", :secret => "bac838a849c1d5c4de2e6a50af826079" }'
     end
 
@@ -128,7 +135,7 @@ module TestHelpers
 
     def add_to_config(str)
       environment = File.read("#{app_path}/config/application.rb")
-      if environment =~ /(\n\s*end\s*)\Z/
+      if environment =~ /(\n\s*end\s*end\s*)\Z/
         File.open("#{app_path}/config/application.rb", 'w') do |f|
           f.puts $` + "\n#{str}\n" + $1
         end

railties/test/plugins/configuration_test.rb

@@ -21,7 +21,7 @@ module PluginsTest
     test "plugin configurations are available in the application" do
       class Foo < Rails::Plugin ; config.foo.greetings = "hello" ; end
       require "#{app_path}/config/application"
-      assert_equal "hello", AppTemplate.config.foo.greetings
+      assert_equal "hello", AppTemplate::Application.config.foo.greetings
     end
 
     test "plugin config merges are deep" do