railties 3.0.0.beta → 3.0.0.beta2

data/lib/rails/generators/test_unit/mailer/templates/functional_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class <%= class_name %>Test < ActionMailer::TestCase
+<% for action in actions -%>
+  test "<%= action %>" do
+    mail = <%= class_name %>.<%= action %>
+    assert_equal <%= action.to_s.humanize.inspect %>, mail.subject
+    assert_equal ["to@example.org"], mail.to
+    assert_equal ["from@example.com"], mail.from
+    assert_match "Hi", mail.body.encoded
+  end
+
+<% end -%>
+<% if actions.blank? -%>
+  # replace this with your real tests
+  test "the truth" do
+    assert true
+  end
+<% end -%>
+end

data/lib/{generators → rails/generators}/test_unit/model/model_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/test_unit'
+require 'rails/generators/test_unit'
 
 module TestUnit
   module Generators

data/lib/{generators → rails/generators}/test_unit/observer/observer_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/test_unit'
+require 'rails/generators/test_unit'
 
 module TestUnit
   module Generators

data/lib/{generators → rails/generators}/test_unit/performance/performance_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/test_unit'
+require 'rails/generators/test_unit'
 
 module TestUnit
   module Generators

data/lib/{generators → rails/generators}/test_unit/plugin/plugin_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/test_unit'
+require 'rails/generators/test_unit'
 
 module TestUnit
   module Generators

data/lib/{generators → rails/generators}/test_unit/scaffold/scaffold_generator.rb

@@ -1,4 +1,4 @@
-require 'generators/test_unit'
+require 'rails/generators/test_unit'
 require 'rails/generators/resource_helpers'
 
 module TestUnit

data/lib/{generators → rails/generators}/test_unit/scaffold/templates/functional_test.rb

@@ -1,6 +1,10 @@
 require 'test_helper'
 
 class <%= controller_class_name %>ControllerTest < ActionController::TestCase
+  setup do
+    @<%= file_name %> = <%= table_name %>(:one)
+  end
+
 <% unless options[:singleton] -%>
   test "should get index" do
     get :index
@@ -16,30 +20,30 @@ class <%= controller_class_name %>ControllerTest < ActionController::TestCase
 
   test "should create <%= file_name %>" do
     assert_difference('<%= class_name %>.count') do
-      post :create, :<%= file_name %> => <%= table_name %>(:one).attributes
+      post :create, :<%= file_name %> => @<%= file_name %>.attributes
     end
 
     assert_redirected_to <%= file_name %>_path(assigns(:<%= file_name %>))
   end
 
   test "should show <%= file_name %>" do
-    get :show, :id => <%= table_name %>(:one).to_param
+    get :show, :id => @<%= file_name %>.to_param
     assert_response :success
   end
 
   test "should get edit" do
-    get :edit, :id => <%= table_name %>(:one).to_param
+    get :edit, :id => @<%= file_name %>.to_param
     assert_response :success
   end
 
   test "should update <%= file_name %>" do
-    put :update, :id => <%= table_name %>(:one).to_param, :<%= file_name %> => <%= table_name %>(:one).attributes
+    put :update, :id => @<%= file_name %>.to_param, :<%= file_name %> => @<%= file_name %>.attributes
     assert_redirected_to <%= file_name %>_path(assigns(:<%= file_name %>))
   end
 
   test "should destroy <%= file_name %>" do
     assert_difference('<%= class_name %>.count', -1) do
-      delete :destroy, :id => <%= table_name %>(:one).to_param
+      delete :destroy, :id => @<%= file_name %>.to_param
     end
 
     assert_redirected_to <%= table_name %>_path

data/{builtin/routes.rb → lib/rails/info_routes.rb}

@@ -1,3 +1,3 @@
-ActionController::Routing::Routes.draw do |map|
+Rails.application.routes.draw do |map|
   match '/rails/info/properties' => "rails/info#properties"
-end
+end

data/lib/rails/{subscriber.rb → log_subscriber.rb}

@@ -2,15 +2,15 @@ require 'active_support/core_ext/class/inheritable_attributes'
 require 'active_support/notifications'
 
 module Rails
-  # Rails::Subscriber is an object set to consume ActiveSupport::Notifications
-  # on initialization with solely purpose of logging. The subscriber dispatches
+  # Rails::LogSubscriber is an object set to consume ActiveSupport::Notifications
+  # on initialization with solely purpose of logging. The log subscriber dispatches
   # notifications to a regirested object based on its given namespace.
   #
-  # An example would be ActiveRecord subscriber responsible for logging queries:
+  # An example would be ActiveRecord log subscriber responsible for logging queries:
   #
   #   module ActiveRecord
   #     class Railtie
-  #       class Subscriber < Rails::Subscriber
+  #       class LogSubscriber < Rails::LogSubscriber
   #         def sql(event)
   #           "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
   #         end
@@ -20,19 +20,19 @@ module Rails
   #
   # It's finally registed as:
   #
-  #   Rails::Subscriber.add :active_record, ActiveRecord::Railtie::Subscriber.new
+  #   Rails::LogSubscriber.add :active_record, ActiveRecord::Railtie::LogSubscriber.new
   #
-  # So whenever a "active_record.sql" notification arrive to Rails::Subscriber,
+  # So whenever a "active_record.sql" notification arrive to Rails::LogSubscriber,
   # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
   # the sql method.
   #
-  # This is useful because it avoids spanning several subscribers just for logging
+  # This is useful because it avoids spanning several log subscribers just for logging
   # purposes(which slows down the main thread). Besides of providing a centralized
   # facility on top of Rails.logger.
-  # 
-  # Subscriber also has some helpers to deal with logging and automatically flushes
+  #
+  # Log subscriber also has some helpers to deal with logging and automatically flushes
   # all logs when the request finishes (via action_dispatch.callback notification).
-  class Subscriber
+  class LogSubscriber
     mattr_accessor :colorize_logging
     self.colorize_logging = true
 
@@ -50,30 +50,29 @@ module Rails
     CYAN       = "\e[36m"
     WHITE      = "\e[37m"
 
-    def self.add(namespace, subscriber)
-      subscribers[namespace.to_sym] = subscriber
-    end
-
-    def self.subscribers
-      @subscribers ||= {}
-    end
+    def self.add(namespace, log_subscriber, notifier = ActiveSupport::Notifications)
+      log_subscribers << log_subscriber
 
-    def self.dispatch(args)
-      namespace, name = args[0].split(".")
-      subscriber = subscribers[namespace.to_sym]
+      log_subscriber.public_methods(false).each do |event|
+        notifier.subscribe("#{namespace}.#{event}") do |*args|
+          next if log_subscriber.logger.nil?
 
-      if subscriber.respond_to?(name) && subscriber.logger
-        begin
-          subscriber.send(name, ActiveSupport::Notifications::Event.new(*args))
-        rescue Exception => e
-          Rails.logger.error "Could not log #{args[0].inspect} event. #{e.class}: #{e.message}"
+          begin
+            log_subscriber.send(event, ActiveSupport::Notifications::Event.new(*args))
+          rescue Exception => e
+            Rails.logger.error "Could not log #{args[0].inspect} event. #{e.class}: #{e.message}"
+          end
         end
       end
     end
 
-    # Flush all subscribers' logger.
+    def self.log_subscribers
+      @log_subscribers ||= []
+    end
+
+    # Flush all log_subscribers' logger.
     def self.flush_all!
-      loggers = subscribers.values.map(&:logger)
+      loggers = log_subscribers.map(&:logger)
       loggers.uniq!
       loggers.each { |l| l.flush if l.respond_to?(:flush) }
     end
@@ -88,6 +87,7 @@ module Rails
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
         def #{level}(*args, &block)
+          return unless logger
           logger.#{level}(*args, &block)
         end
       METHOD

data/lib/rails/{subscriber → log_subscriber}/test_helper.rb

@@ -1,13 +1,13 @@
-require 'rails/subscriber'
+require 'rails/log_subscriber'
 
 module Rails
-  class Subscriber
-    # Provides some helpers to deal with testing subscribers by setting up
+  class LogSubscriber
+    # Provides some helpers to deal with testing log subscribers by setting up
     # notifications. Take for instance ActiveRecord subscriber tests:
     #
-    #   class SyncSubscriberTest < ActiveSupport::TestCase
-    #     include Rails::Subscriber::TestHelper
-    #     Rails::Subscriber.add(:active_record, ActiveRecord::Railties::Subscriber.new)
+    #   class SyncLogSubscriberTest < ActiveSupport::TestCase
+    #     include Rails::LogSubscriber::TestHelper
+    #     Rails::LogSubscriber.add(:active_record, ActiveRecord::Railties::LogSubscriber.new)
     # 
     #     def test_basic_query_logging
     #       Developer.all
@@ -17,18 +17,18 @@ module Rails
     #       assert_match /SELECT \* FROM "developers"/, @logger.logged(:debug).last
     #     end
     # 
-    #     class SyncSubscriberTest < ActiveSupport::TestCase
-    #       include Rails::Subscriber::SyncTestHelper
-    #       include SubscriberTest
+    #     class SyncLogSubscriberTest < ActiveSupport::TestCase
+    #       include Rails::LogSubscriber::SyncTestHelper
+    #       include LogSubscriberTest
     #     end
     # 
-    #     class AsyncSubscriberTest < ActiveSupport::TestCase
-    #       include Rails::Subscriber::AsyncTestHelper
-    #       include SubscriberTest
+    #     class AsyncLogSubscriberTest < ActiveSupport::TestCase
+    #       include Rails::LogSubscriber::AsyncTestHelper
+    #       include LogSubscriberTest
     #     end
     #   end
     #
-    # All you need to do is to ensure that your subscriber is added to Rails::Subscriber,
+    # All you need to do is to ensure that your log subscriber is added to Rails::Subscriber,
     # as in the second line of the code above. The test helpers is reponsible for setting
     # up the queue, subscriptions and turning colors in logs off.
     #
@@ -42,8 +42,7 @@ module Rails
         @logger   = MockLogger.new
         @notifier = ActiveSupport::Notifications::Notifier.new(queue)
 
-        Rails::Subscriber.colorize_logging = false
-        @notifier.subscribe { |*args| Rails::Subscriber.dispatch(args) }
+        Rails::LogSubscriber.colorize_logging = false
 
         set_logger(@logger)
         ActiveSupport::Notifications.notifier = @notifier
@@ -80,7 +79,7 @@ module Rails
         @notifier.wait
       end
 
-      # Overwrite if you use another logger in your subscriber:
+      # Overwrite if you use another logger in your log subscriber:
       #
       #   def logger
       #     ActiveRecord::Base.logger = @logger

data/lib/rails/plugin.rb

@@ -1,6 +1,22 @@
 require 'rails/engine'
+require 'active_support/core_ext/array/conversions'
 
 module Rails
+  # Rails::Plugin is nothing more than a Rails::Engine, but since it's loaded too late
+  # in the boot process, it does not have the same configuration powers as a bare
+  # Rails::Engine.
+  #
+  # Opposite to Rails::Railtie and Rails::Engine, you are not supposed to inherit from
+  # Rails::Plugin. Rails::Plugin is automatically configured to be an engine by simply
+  # placing inside vendor/plugins. Since this is done automatically, you actually cannot
+  # declare a Rails::Engine inside your Plugin, otherwise it would cause the same files
+  # to be loaded twice. This means that if you want to ship an Engine as gem it cannot
+  # be used as plugin and vice-versa.
+  #
+  # Besides this conceptual difference, the only difference between Rails::Engine and
+  # Rails::Plugin is that plugins automatically load the file "init.rb" at the plugin
+  # root during the boot process.
+  # 
   class Plugin < Engine
     def self.inherited(base)
       raise "You cannot inherit from Rails::Plugin"
@@ -25,12 +41,14 @@ module Rails
 
     def load_tasks
       super
-      extra_tasks = Dir["#{root}/{tasks,rails/tasks}/**/*.rake"]
+      load_deprecated_tasks
+    end
 
-      unless extra_tasks.empty?
-        ActiveSupport::Deprecation.warn "Having rake tasks in PLUGIN_PATH/tasks or " <<
-          "PLUGIN_PATH/rails/tasks is deprecated. Use to PLUGIN_PATH/lib/tasks instead"
-        extra_tasks.sort.each { |ext| load(ext) }
+    def load_deprecated_tasks
+      tasks = Dir["#{root}/{tasks,rails/tasks}/**/*.rake"].sort
+      if tasks.any?
+        ActiveSupport::Deprecation.warn "Rake tasks in #{tasks.to_sentence} are deprecated. Use lib/tasks instead"
+        tasks.each { |ext| load(ext) }
       end
     end
 
@@ -44,9 +62,14 @@ module Rails
     end
 
     initializer :load_init_rb, :before => :load_application_initializers do |app|
-      file   = Dir["#{root}/{rails/init,init}.rb"].first
-      config = app.config
-      eval(File.read(file), binding, file) if file && File.file?(file)
+      files = %w(rails/init.rb init.rb).map { |path| File.expand_path path, root }
+      if initrb = files.find { |path| File.file? path }
+        if initrb == files.first
+          ActiveSupport::Deprecation.warn "Use toplevel init.rb; rails/init.rb is deprecated: #{initrb}"
+        end
+        config = app.config
+        eval(File.read(initrb), binding, initrb)
+      end
     end
 
     initializer :sanity_check_railties_collision do

data/lib/rails/rack/debugger.rb

@@ -1,10 +1,12 @@
+require 'active_support/core_ext/kernel/requires'
+
 module Rails
   module Rack
     class Debugger
       def initialize(app)
         @app = app
 
-        ARGV.clear # clear ARGV so that script/server options aren't passed to IRB
+        ARGV.clear # clear ARGV so that rails server options aren't passed to IRB
 
         require_library_or_gem 'ruby-debug'
         ::Debugger.start

data/lib/rails/rack/logger.rb

@@ -1,9 +1,9 @@
-require 'rails/subscriber'
+require 'rails/log_subscriber'
 
 module Rails
   module Rack
     # Log the request started and flush all loggers after it.
-    class Logger < Rails::Subscriber
+    class Logger < Rails::LogSubscriber
       def initialize(app)
         @app = app
       end
@@ -19,14 +19,14 @@ module Rails
 
         def before_dispatch(env)
           request = ActionDispatch::Request.new(env)
-          path = request.request_uri.inspect rescue "unknown"
+          path = request.fullpath.inspect rescue "unknown"
 
           info "\n\nStarted #{request.method.to_s.upcase} #{path} " <<
                       "for #{request.remote_ip} at #{Time.now.to_s(:db)}"
         end
 
         def after_dispatch(env)
-          Rails::Subscriber.flush_all!
+          Rails::LogSubscriber.flush_all!
         end
 
     end

data/lib/rails/railtie.rb

@@ -1,14 +1,185 @@
 require 'rails/initializable'
 require 'rails/configuration'
+require 'active_support/inflector'
 
 module Rails
+  # Railtie is the core of the Rails Framework and provides several hooks to extend
+  # Rails and/or modify the initialization process.
+  # 
+  # Every major component of Rails (Action Mailer, Action Controller,
+  # Action View, Active Record and Active Resource) are all Railties, so each of
+  # them is responsible to set their own initialization. This makes, for example,
+  # Rails absent of any ActiveRecord hook, allowing any other ORM framework to hook in.
+  # 
+  # Developing a Rails extension does _not_ require any implementation of
+  # Railtie, but if you need to interact with the Rails framework during
+  # or after boot, then Railtie is what you need to do that interaction.
+  # 
+  # For example, the following would need you to implement Railtie in your
+  # plugin:
+  # 
+  # * creating initializers
+  # * configuring a Rails framework or the Application, like setting a generator
+  # * adding Rails config.* keys to the environment
+  # * setting up a subscriber to the Rails +ActiveSupport::Notifications+
+  # * adding rake tasks into rails
+  # 
+  # == Creating your Railtie
+  #
+  # Implementing Railtie in your Rails extension is done by creating a class
+  # Railtie that has your extension name and making sure that this gets loaded
+  # during boot time of the Rails stack.
+  # 
+  # You can do this however you wish, but here is an example if you want to provide
+  # it for a gem that can be used with or without Rails:
+  # 
+  # * Create a file (say, lib/my_gem/railtie.rb) which contains class Railtie inheriting from
+  #   Rails::Railtie and is namespaced to your gem:
+  #
+  #   # lib/my_gem/railtie.rb
+  #   module MyGem
+  #     class Railtie < Rails::Railtie
+  #       railtie_name :mygem
+  #     end
+  #   end
+  # 
+  # * Require your own gem as well as rails in this file:
+  # 
+  #   # lib/my_gem/railtie.rb
+  #   require 'my_gem'
+  #   require 'rails'
+  # 
+  #   module MyGem
+  #     class Railtie < Rails::Railtie
+  #       railtie_name :mygem
+  #     end
+  #   end
+  #   
+  # * Make sure your Gem loads the railtie.rb file if Rails is loaded first, an easy
+  #   way to check is by checking for the Rails constant which will exist if Rails
+  #   has started:
+  # 
+  #   # lib/my_gem.rb
+  #   module MyGem
+  #     require 'lib/my_gem/railtie' if defined?(Rails)
+  #   end
+  # 
+  # * Or instead of doing the require automatically, you can ask your users to require
+  #   it for you in their Gemfile:
+  # 
+  #   # #{USER_RAILS_ROOT}/Gemfile
+  #   gem "my_gem", :require_as => ["my_gem", "my_gem/railtie"]
+  #
+  # == Initializers
+  #
+  # To add an initialization step from your Railtie to Rails boot process, you just need
+  # to create an initializer block:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     initializer "my_railtie.configure_rails_initialization" do
+  #       # some initialization behavior
+  #     end
+  #   end
+  #
+  # If specified, the block can also receive the application object, in case you 
+  # need to access some application specific configuration:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     initializer "my_railtie.configure_rails_initialization" do |app|
+  #       if app.config.cache_classes
+  #         # some initialization behavior
+  #       end
+  #     end
+  #   end
+  #
+  # Finally, you can also pass :before and :after as option to initializer, in case
+  # you want to couple it with a specific step in the initialization process.
+  #
+  # == Configuration
+  #
+  # Inside the Railtie class, you can access a config object which contains configuration
+  # shared by all railties and the application:
+  #
+  #   class MyRailtie < Rails::Railtie
+  #     # Customize the ORM
+  #     config.generators.orm :my_railtie_orm
+  #
+  #     # Add a middleware
+  #     config.middlewares.use MyRailtie::Middleware
+  #
+  #     # Add a to_prepare block which is executed once in production
+  #     # and before which request in development
+  #     config.to_prepare do
+  #       MyRailtie.setup!
+  #     end
+  #   end
+  #
+  # == Loading rake tasks and generators
+  #
+  # If your railtie has rake tasks, you can tell Rails to load them through the method
+  # rake tasks:
+  #
+  #   class MyRailtie < Railtie
+  #     rake_tasks do
+  #       load "path/to/my_railtie.tasks"
+  #     end
+  #   end
+  #
+  # By default, Rails load generators from your load path. However, if you want to place
+  # your generators at a different location, you can specify in your Railtie a block which
+  # will load them during normal generators lookup:
+  #
+  #   class MyRailtie < Railtie
+  #     generators do
+  #       require "path/to/my_railtie_generator"
+  #     end
+  #   end
+  #
+  # == Adding your subscriber
+  #
+  # Since version 3.0, Rails ships with a notification system which is used for several
+  # purposes, including logging. If you are sending notifications in your Railtie, you may
+  # want to add a subscriber to consume such notifications for logging purposes.
+  #
+  # The subscriber is added under the railtie_name namespace and only consumes notifications
+  # under the given namespace. For example, let's suppose your railtie is publishing the
+  # following "something_expensive" instrumentation:
+  #
+  #   ActiveSupport::Notifications.instrument "my_railtie.something_expensive" do
+  #     # something expensive
+  #   end
+  #
+  # You can log this instrumentation with your own Rails::Subscriber:
+  #
+  #   class MyRailtie::Subscriber < Rails::Subscriber
+  #     def something_expensive(event)
+  #       info("Something expensive took %.1fms" % event.duration)
+  #     end
+  #   end
+  #
+  # By registering it:
+  #
+  #   class MyRailtie < Railtie
+  #     subscriber MyRailtie::Subscriber.new
+  #   end
+  #
+  # Take a look in Rails::Subscriber docs for more information.
+  #
+  # == Application, Plugin and Engine
+  #
+  # A Rails::Engine is nothing more than a Railtie with some initializers already set.
+  # And since Rails::Application and Rails::Plugin are engines, the same configuration
+  # described here can be used in all three.
+  #
+  # Be sure to look at the documentation of those specific classes for more information.
+  # 
   class Railtie
     autoload :Configurable,  "rails/railtie/configurable"
     autoload :Configuration, "rails/railtie/configuration"
 
     include Initializable
 
-    ABSTRACT_RAILTIES = %w(Rails::Plugin Rails::Engine Rails::Application)
+    ABSTRACT_RAILTIES = %w(Rails::Railtie Rails::Plugin Rails::Engine Rails::Application)
 
     class << self
       def subclasses
@@ -16,24 +187,18 @@ module Rails
       end
 
       def inherited(base)
-        unless abstract_railtie?(base)
+        unless base.abstract_railtie?
           base.send(:include, self::Configurable)
           subclasses << base
         end
       end
 
-      def railtie_name(railtie_name = nil)
-        @railtie_name ||= name.demodulize.underscore
-        @railtie_name = railtie_name if railtie_name
-        @railtie_name
+      def railtie_name(*)
+        ActiveSupport::Deprecation.warn "railtie_name is deprecated and has no effect", caller
       end
 
-      def railtie_names
-        subclasses.map { |p| p.railtie_name }
-      end
-
-      def subscriber(subscriber)
-        Rails::Subscriber.add(railtie_name, subscriber)
+      def log_subscriber(name, log_subscriber)
+        Rails::LogSubscriber.add(name, log_subscriber)
       end
 
       def rake_tasks(&blk)
@@ -48,10 +213,8 @@ module Rails
         @generators
       end
 
-    protected
-
-      def abstract_railtie?(base)
-        ABSTRACT_RAILTIES.include?(base.name)
+      def abstract_railtie?
+        ABSTRACT_RAILTIES.include?(name)
       end
     end