railties 3.0.0.beta

data/lib/rails/railtie/configurable.rb

@@ -0,0 +1,23 @@
+module Rails
+  class Railtie
+    module Configurable
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def config
+          @config ||= Railtie::Configuration.new
+        end
+
+        def inherited(base)
+          raise "You cannot inherit from a Rails::Railtie child"
+        end
+      end
+
+      def config
+        self.class.config
+      end
+    end
+  end
+end

data/lib/rails/railtie/configuration.rb

@@ -0,0 +1,9 @@
+require 'rails/configuration'
+
+module Rails
+  class Railtie
+    class Configuration
+      include Rails::Configuration::Shared
+    end
+  end
+end

data/lib/rails/railties_path.rb

@@ -0,0 +1 @@
+RAILTIES_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))

data/lib/rails/ruby_version_check.rb

@@ -0,0 +1,10 @@
+min_release  = "1.8.7"
+ruby_release = "#{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+if ruby_release < min_release
+  abort <<-end_message
+
+    Rails requires Ruby version #{min_release} or later.
+    You're running #{ruby_release}; please upgrade to continue.
+
+  end_message
+end

data/lib/rails/rubyprof_ext.rb

@@ -0,0 +1,35 @@
+require 'prof'
+
+module Prof #:nodoc:
+  # Adapted from Shugo Maeda's unprof.rb
+  def self.print_profile(results, io = $stderr)
+    total = results.detect { |i|
+      i.method_class.nil? && i.method_id == :"#toplevel"
+    }.total_time
+    total = 0.001 if total < 0.001
+
+    io.puts "  %%   cumulative   self              self     total"
+    io.puts " time   seconds   seconds    calls  ms/call  ms/call  name"
+
+    sum = 0.0
+    for r in results
+      sum += r.self_time
+
+      name =  if r.method_class.nil?
+                r.method_id.to_s
+              elsif r.method_class.is_a?(Class)
+                "#{r.method_class}##{r.method_id}"
+              else
+                "#{r.method_class}.#{r.method_id}"
+              end
+      io.printf "%6.2f %8.3f  %8.3f %8d %8.2f %8.2f  %s\n",
+        r.self_time / total * 100,
+        sum,
+        r.self_time,
+        r.count,
+        r.self_time * 1000 / r.count,
+        r.total_time * 1000 / r.count,
+        name
+    end
+  end
+end

data/lib/rails/source_annotation_extractor.rb

@@ -0,0 +1,102 @@
+# Implements the logic behind the rake tasks for annotations like
+#
+#   rake notes
+#   rake notes:optimize
+#
+# and friends. See <tt>rake -T notes</tt> and <tt>railties/lib/tasks/annotations.rake</tt>.
+#
+# Annotation objects are triplets <tt>:line</tt>, <tt>:tag</tt>, <tt>:text</tt> that
+# represent the line where the annotation lives, its tag, and its text. Note
+# the filename is not stored.
+#
+# Annotations are looked for in comments and modulus whitespace they have to
+# start with the tag optionally followed by a colon. Everything up to the end
+# of the line (or closing ERb comment tag) is considered to be their text.
+class SourceAnnotationExtractor
+  class Annotation < Struct.new(:line, :tag, :text)
+
+    # Returns a representation of the annotation that looks like this:
+    #
+    #   [126] [TODO] This algorithm is simple and clearly correct, make it faster.
+    #
+    # If +options+ has a flag <tt>:tag</tt> the tag is shown as in the example above.
+    # Otherwise the string contains just line and text.
+    def to_s(options={})
+      s = "[%3d] " % line
+      s << "[#{tag}] " if options[:tag]
+      s << text
+    end
+  end
+
+  # Prints all annotations with tag +tag+ under the root directories +app+, +lib+,
+  # and +test+ (recursively). Only filenames with extension +.builder+, +.rb+,
+  # +.rxml+, +.rjs+, +.rhtml+, or +.erb+ are taken into account. The +options+
+  # hash is passed to each annotation's +to_s+.
+  #
+  # This class method is the single entry point for the rake tasks.
+  def self.enumerate(tag, options={})
+    extractor = new(tag)
+    extractor.display(extractor.find, options)
+  end
+
+  attr_reader :tag
+
+  def initialize(tag)
+    @tag = tag
+  end
+
+  # Returns a hash that maps filenames under +dirs+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.rxml+, +.rjs+, +.rhtml+, and +.erb+
+  # are taken into account.
+  def find(dirs=%w(app lib test))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+
+  # Returns a hash that maps filenames under +dir+ (recursively) to arrays
+  # with their annotations. Only files with annotations are included, and only
+  # those with extension +.builder+, +.rb+, +.rxml+, +.rjs+, +.rhtml+, and +.erb+
+  # are taken into account.
+  def find_in(dir)
+    results = {}
+
+    Dir.glob("#{dir}/*") do |item|
+      next if File.basename(item)[0] == ?.
+
+      if File.directory?(item)
+        results.update(find_in(item))
+      elsif item =~ /\.(builder|(r(?:b|xml|js)))$/
+        results.update(extract_annotations_from(item, /#\s*(#{tag}):?\s*(.*)$/))
+      elsif item =~ /\.(rhtml|erb)$/
+        results.update(extract_annotations_from(item, /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/))
+      end
+    end
+
+    results
+  end
+
+  # If +file+ is the filename of a file that contains annotations this method returns
+  # a hash with a single entry that maps +file+ to an array of its annotations.
+  # Otherwise it returns an empty hash.
+  def extract_annotations_from(file, pattern)
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless line =~ pattern
+      list << Annotation.new(lineno, $1, $2)
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  # Prints the mapping from filenames to annotations in +results+ ordered by filename.
+  # The +options+ hash is passed to each annotation's +to_s+.
+  def display(results, options={})
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(options)}"
+      end
+      puts
+    end
+  end
+end

data/lib/rails/subscriber.rb

@@ -0,0 +1,108 @@
+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
+  # notifications to a regirested object based on its given namespace.
+  #
+  # An example would be ActiveRecord subscriber responsible for logging queries:
+  #
+  #   module ActiveRecord
+  #     class Railtie
+  #       class Subscriber < Rails::Subscriber
+  #         def sql(event)
+  #           "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  # It's finally registed as:
+  #
+  #   Rails::Subscriber.add :active_record, ActiveRecord::Railtie::Subscriber.new
+  #
+  # So whenever a "active_record.sql" notification arrive to Rails::Subscriber,
+  # 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
+  # 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
+  # all logs when the request finishes (via action_dispatch.callback notification).
+  class Subscriber
+    mattr_accessor :colorize_logging
+    self.colorize_logging = true
+
+    # Embed in a String to clear all previous ANSI sequences.
+    CLEAR      = "\e[0m"
+    BOLD       = "\e[1m"
+
+    # Colors
+    BLACK      = "\e[30m"
+    RED        = "\e[31m"
+    GREEN      = "\e[32m"
+    YELLOW     = "\e[33m"
+    BLUE       = "\e[34m"
+    MAGENTA    = "\e[35m"
+    CYAN       = "\e[36m"
+    WHITE      = "\e[37m"
+
+    def self.add(namespace, subscriber)
+      subscribers[namespace.to_sym] = subscriber
+    end
+
+    def self.subscribers
+      @subscribers ||= {}
+    end
+
+    def self.dispatch(args)
+      namespace, name = args[0].split(".")
+      subscriber = subscribers[namespace.to_sym]
+
+      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}"
+        end
+      end
+    end
+
+    # Flush all subscribers' logger.
+    def self.flush_all!
+      loggers = subscribers.values.map(&:logger)
+      loggers.uniq!
+      loggers.each { |l| l.flush if l.respond_to?(:flush) }
+    end
+
+    # By default, we use the Rails.logger for logging.
+    def logger
+      Rails.logger
+    end
+
+  protected
+
+    %w(info debug warn error fatal unknown).each do |level|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{level}(*args, &block)
+          logger.#{level}(*args, &block)
+        end
+      METHOD
+    end
+
+    # Set color by using a string or one of the defined constants. If a third
+    # option is set to true, it also adds bold to the string. This is based
+    # on Highline implementation and it automatically appends CLEAR to the end
+    # of the returned String.
+    #
+    def color(text, color, bold=false)
+      return text unless colorize_logging
+      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+      bold  = bold ? BOLD : ""
+      "#{bold}#{color}#{text}#{CLEAR}"
+    end
+  end
+end

data/lib/rails/subscriber/test_helper.rb

@@ -0,0 +1,98 @@
+require 'rails/subscriber'
+
+module Rails
+  class Subscriber
+    # Provides some helpers to deal with testing 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)
+    # 
+    #     def test_basic_query_logging
+    #       Developer.all
+    #       wait
+    #       assert_equal 1, @logger.logged(:debug).size
+    #       assert_match /Developer Load/, @logger.logged(:debug).last
+    #       assert_match /SELECT \* FROM "developers"/, @logger.logged(:debug).last
+    #     end
+    # 
+    #     class SyncSubscriberTest < ActiveSupport::TestCase
+    #       include Rails::Subscriber::SyncTestHelper
+    #       include SubscriberTest
+    #     end
+    # 
+    #     class AsyncSubscriberTest < ActiveSupport::TestCase
+    #       include Rails::Subscriber::AsyncTestHelper
+    #       include SubscriberTest
+    #     end
+    #   end
+    #
+    # All you need to do is to ensure that your 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.
+    #
+    # The messages are available in the @logger instance, which is a logger with limited
+    # powers (it actually do not send anything to your output), and you can collect them
+    # doing @logger.logged(level), where level is the level used in logging, like info,
+    # debug, warn and so on.
+    #
+    module TestHelper
+      def setup
+        @logger   = MockLogger.new
+        @notifier = ActiveSupport::Notifications::Notifier.new(queue)
+
+        Rails::Subscriber.colorize_logging = false
+        @notifier.subscribe { |*args| Rails::Subscriber.dispatch(args) }
+
+        set_logger(@logger)
+        ActiveSupport::Notifications.notifier = @notifier
+      end
+
+      def teardown
+        set_logger(nil)
+        ActiveSupport::Notifications.notifier = nil
+      end
+
+      class MockLogger
+        attr_reader :flush_count
+
+        def initialize
+          @flush_count = 0
+          @logged = Hash.new { |h,k| h[k] = [] }
+        end
+
+        def method_missing(level, message)
+          @logged[level] << message
+        end
+
+        def logged(level)
+          @logged[level].compact.map { |l| l.to_s.strip }
+        end
+
+        def flush
+          @flush_count += 1
+        end
+      end
+
+      # Wait notifications to be published.
+      def wait
+        @notifier.wait
+      end
+
+      # Overwrite if you use another logger in your subscriber:
+      #
+      #   def logger
+      #     ActiveRecord::Base.logger = @logger
+      #   end
+      #
+      def set_logger(logger)
+        Rails.logger = logger
+      end
+
+      def queue
+        ActiveSupport::Notifications::Fanout.new
+      end
+    end
+  end
+end

data/lib/rails/tasks.rb

@@ -0,0 +1,16 @@
+$VERBOSE = nil
+
+# Load Rails rakefile extensions
+%w(
+  annotations
+  documentation
+  framework
+  log
+  middleware
+  misc
+  routes
+  statistics
+  tmp
+).each do |task|
+  load "rails/tasks/#{task}.rake"
+end

data/lib/rails/tasks/annotations.rake

@@ -0,0 +1,20 @@
+require 'rails/source_annotation_extractor'
+
+desc "Enumerate all annotations"
+task :notes do
+  SourceAnnotationExtractor.enumerate "OPTIMIZE|FIXME|TODO", :tag => true
+end
+
+namespace :notes do
+  ["OPTIMIZE", "FIXME", "TODO"].each do |annotation|
+    desc "Enumerate all #{annotation} annotations"
+    task annotation.downcase.intern do
+      SourceAnnotationExtractor.enumerate annotation
+    end
+  end
+
+  desc "Enumerate a custom annotation, specify with ANNOTATION=CUSTOM"
+  task :custom do
+    SourceAnnotationExtractor.enumerate ENV['ANNOTATION']
+  end
+end

data/lib/rails/tasks/documentation.rake

@@ -0,0 +1,96 @@
+namespace :doc do
+  desc "Generate documentation for the application. Set custom template with TEMPLATE=/path/to/rdoc/template.rb or title with TITLE=\"Custom Title\""
+  Rake::RDocTask.new("app") { |rdoc|
+    rdoc.rdoc_dir = 'doc/app'
+    rdoc.template = ENV['template'] if ENV['template']
+    rdoc.title    = ENV['title'] || "Rails Application Documentation"
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.options << '--charset' << 'utf-8'
+    rdoc.rdoc_files.include('doc/README_FOR_APP')
+    rdoc.rdoc_files.include('app/**/*.rb')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  }
+
+  desc 'Generate documentation for the Rails framework. Specify path with PATH="/path/to/rails"'
+  Rake::RDocTask.new("rails") { |rdoc|
+    path = ENV['RAILS_PATH'] || 'vendor/gems/gems'
+    version = '-3.0.0.beta' unless ENV['RAILS_PATH']
+    rdoc.rdoc_dir = 'doc/api'
+    rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+    rdoc.title    = "Rails Framework Documentation"
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('README')
+
+    %w(README CHANGELOG lib/action_mailer/base.rb).each do |file|
+      rdoc.rdoc_files.include("#{path}/actionmailer#{version}/#{file}")
+    end
+
+    %w(README CHANGELOG lib/action_controller/**/*.rb lib/action_view/**/*.rb).each do |file|
+      rdoc.rdoc_files.include("#{path}/actionpack#{version}/#{file}")
+    end
+
+    %w(README CHANGELOG lib/active_model/**/*.rb).each do |file|
+      rdoc.rdoc_files.include("#{path}/activemodel#{version}/#{file}")
+    end
+
+    %w(README CHANGELOG lib/active_record/**/*.rb).each do |file|
+      rdoc.rdoc_files.include("#{path}/activerecord#{version}/#{file}")
+    end
+
+    %w(README CHANGELOG lib/active_resource.rb lib/active_resource/*).each do |file|
+      rdoc.rdoc_files.include("#{path}/activeresource#{version}/#{file}")
+    end
+
+    %w(README CHANGELOG lib/active_support/**/*.rb).each do |file|
+      rdoc.rdoc_files.include("#{path}/activesupport#{version}/#{file}")
+    end
+
+    %w(README CHANGELOG MIT-LICENSE lib/{*.rb,commands/*.rb,generators/*.rb}).each do |file|
+      rdoc.rdoc_files.include("#{path}/railties#{version}/#{file}")
+    end
+  }
+
+  plugins = FileList['vendor/plugins/**'].collect { |plugin| File.basename(plugin) }
+
+  desc "Generate documentation for all installed plugins"
+  task :plugins => plugins.collect { |plugin| "doc:plugins:#{plugin}" }
+
+  desc "Remove plugin documentation"
+  task :clobber_plugins do 
+    rm_rf 'doc/plugins' rescue nil
+  end
+
+  desc "Generate Rails guides"
+  task :guides do
+    require File.join(RAILTIES_PATH, "guides/rails_guides")
+    RailsGuides::Generator.new(Rails.root.join("doc/guides")).generate
+  end
+
+  namespace :plugins do
+    # Define doc tasks for each plugin
+    plugins.each do |plugin|
+      desc "Generate documentation for the #{plugin} plugin"
+      task(plugin => :environment) do
+        plugin_base   = "vendor/plugins/#{plugin}"
+        options       = []
+        files         = Rake::FileList.new
+        options << "-o doc/plugins/#{plugin}"
+        options << "--title '#{plugin.titlecase} Plugin Documentation'"
+        options << '--line-numbers' << '--inline-source'
+        options << '--charset' << 'utf-8'
+        options << '-T html'
+
+        files.include("#{plugin_base}/lib/**/*.rb")
+        if File.exist?("#{plugin_base}/README")
+          files.include("#{plugin_base}/README")    
+          options << "--main '#{plugin_base}/README'"
+        end
+        files.include("#{plugin_base}/CHANGELOG") if File.exist?("#{plugin_base}/CHANGELOG")
+
+        options << files.to_s
+
+        sh %(rdoc #{options * ' '})
+      end
+    end
+  end
+end