railties 3.0.0.beta

data/lib/rails/application/routes_reloader.rb

@@ -0,0 +1,46 @@
+module Rails
+  class Application
+    class RoutesReloader
+      attr_reader :paths
+
+      def initialize
+        @paths, @last_change_at = [], nil
+      end
+
+      def changed_at
+        routes_changed_at = nil
+
+        paths.each do |path|
+          config_changed_at = File.stat(path).mtime
+
+          if routes_changed_at.nil? || config_changed_at > routes_changed_at
+            routes_changed_at = config_changed_at
+          end
+        end
+
+        routes_changed_at
+      end
+
+      def reload!
+        routes = Rails::Application.routes
+        routes.disable_clear_and_finalize = true
+
+        routes.clear!
+        paths.each { |path| load(path) }
+        routes.finalize!
+
+        nil
+      ensure
+        routes.disable_clear_and_finalize = false
+      end
+
+      def reload_if_changed
+        current_change_at = changed_at
+        if @last_change_at != current_change_at
+          @last_change_at = current_change_at
+          reload!
+        end
+      end
+    end
+  end
+end

data/lib/rails/backtrace_cleaner.rb

@@ -0,0 +1,54 @@
+require 'active_support/backtrace_cleaner'
+
+module Rails
+  class BacktraceCleaner < ActiveSupport::BacktraceCleaner
+    ERB_METHOD_SIG = /:in `_run_erb_.*/
+    APP_DIRS = %w( app config lib test )
+
+    def initialize
+      super
+      add_filter   { |line| line.sub("#{Rails.root}/", '') }
+      add_filter   { |line| line.sub(ERB_METHOD_SIG, '') }
+      add_filter   { |line| line.sub('./', '/') } # for tests
+
+      add_gem_filters
+      add_bundler_filters
+
+      add_silencer { |line| !APP_DIRS.any? { |dir| line =~ /^#{dir}/ } }
+    end
+
+    private
+      def add_gem_filters
+        return unless defined? Gem
+        (Gem.path + [Gem.default_dir]).uniq.each do |path|
+          # http://gist.github.com/30430
+          add_filter { |line|
+            line.sub(%r{(#{path})/gems/([^/]+)-([0-9.]+)/(.*)}, '\2 (\3) \4')
+          }
+        end
+      end
+
+      def add_bundler_filters
+        return unless defined? Bundler
+        add_filter { |line|
+          line.sub(%r{vendor/gems/[^/]+/[^/]+/gems/([^/]+)-([0-9.]+)/(.*)}, '\1 (\2) \3')
+        }
+        add_filter { |line|
+          line.sub(%r{vendor/gems/[^/]+/[^/]+/dirs/([^/]+)/(.*)}, '\1 \2')
+        }
+      end
+  end
+
+  # For installing the BacktraceCleaner in the test/unit
+  module BacktraceFilterForTestUnit #:nodoc:
+    def self.included(klass)
+      klass.send :alias_method_chain, :filter_backtrace, :cleaning
+    end
+
+    def filter_backtrace_with_cleaning(backtrace, prefix=nil)
+      backtrace = filter_backtrace_without_cleaning(backtrace, prefix)
+      backtrace = backtrace.first.split("\n") if backtrace.size == 1
+      Rails.backtrace_cleaner.clean(backtrace)
+    end
+  end
+end

data/lib/rails/code_statistics.rb

@@ -0,0 +1,107 @@
+class CodeStatistics #:nodoc:
+
+  TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests)
+
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
+          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
+          stats.each { |k, v| stats[k] += newstats[k] }
+        end
+
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def calculate_code
+      code_loc = 0
+      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
+      code_loc
+    end
+
+    def calculate_tests
+      test_loc = 0
+      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
+      test_loc
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      start = if TEST_TYPES.include? name
+        "| #{name.ljust(20)} "
+      else
+        "| #{name.ljust(20)} " 
+      end
+
+      puts start + 
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+
+    def print_code_test_stats
+      code  = calculate_code
+      tests = calculate_tests
+
+      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
+      puts ""
+    end
+  end

data/lib/rails/commands.rb

@@ -0,0 +1,72 @@
+if ARGV.empty?
+  ARGV << '--help'
+end
+
+HELP_TEXT = <<-EOT
+Usage: rails COMMAND [ARGS]
+
+The most common rails commands are:
+ generate    Generate new code (short-cut alias: "g")
+ console     Start the Rails console (short-cut alias: "c")
+ server      Start the Rails server (short-cut alias: "s")
+ dbconsole   Start a console for the database specified in config/database.yml
+             (short-cut alias: "db")
+
+In addition to those, there are:
+ application  Generate the Rails application code
+ destroy      Undo code generated with "generate"
+ benchmarker  See how fast a piece of code runs
+ profiler     Get profile information from a piece of code
+ plugin       Install a plugin
+ runner       Run a piece of code in the application environment
+
+All commands can be run with -h for more information.
+EOT
+
+
+case ARGV.shift
+when 'g', 'generate'
+  require ENV_PATH
+  require 'rails/commands/generate'
+when 'c', 'console'
+  require 'rails/commands/console'
+  require APP_PATH
+  Rails::Console.start(Rails::Application)
+when 's', 'server'
+  require APP_PATH
+  require 'rails/commands/server'
+  Dir.chdir(ROOT_PATH)
+  Rails::Server.start
+when 'db', 'dbconsole'
+  require 'rails/commands/dbconsole'
+  require APP_PATH
+  Rails::DBConsole.start(Rails::Application)
+
+when 'application'
+  require 'rails/commands/application'
+when 'destroy'
+  require ENV_PATH
+  require 'rails/commands/destroy'
+when 'benchmarker'
+  require ENV_PATH
+  require 'rails/commands/performance/benchmarker'
+when 'profiler'
+  require ENV_PATH
+  require 'rails/commands/performance/profiler'
+when 'plugin'
+  require APP_PATH
+  require 'rails/commands/plugin'
+when 'runner'
+  require 'rails/commands/runner'
+  require ENV_PATH
+
+
+when '--help', '-h'
+  puts HELP_TEXT
+when '--version', '-v'
+  ARGV.unshift '--version'
+  require 'rails/commands/application'
+else
+  puts "Error: Command not recognized"
+  puts HELP_TEXT
+end

data/lib/rails/commands/application.rb

@@ -0,0 +1,13 @@
+require 'rails/version'
+if %w(--version -v).include? ARGV.first
+  puts "Rails #{Rails::VERSION::STRING}"
+  exit(0)
+end
+
+ARGV << "--help"   if ARGV.empty?
+require 'rubygems' if ARGV.include?("--dev")
+
+require 'rails/generators'
+require 'generators/rails/app/app_generator'
+
+Rails::Generators::AppGenerator.start

data/lib/rails/commands/console.rb

@@ -0,0 +1,55 @@
+require 'optparse'
+require 'irb'
+require 'irb/completion'
+
+module Rails
+  class Console
+    def self.start(app)
+      new(app).start
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def start
+      options = {}
+
+      OptionParser.new do |opt|
+        opt.banner = "Usage: console [environment] [options]"
+        opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |v| options[:sandbox] = v }
+        opt.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = v }
+        opt.on('--irb') { |v| abort '--irb option is no longer supported. Invoke `/your/choice/of/ruby script/console` instead' }
+        opt.parse!(ARGV)
+      end
+
+      @app.initialize!
+      require "rails/console/app"
+      require "rails/console/sandbox" if options[:sandbox]
+      require "rails/console/helpers"
+
+      if options[:debugger]
+        begin
+          require 'ruby-debug'
+          puts "=> Debugger enabled"
+        rescue Exception
+          puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
+          exit
+        end
+      end
+
+      if options[:sandbox]
+        puts "Loading #{Rails.env} environment in sandbox (Rails #{Rails.version})"
+        puts "Any modifications you make will be rolled back on exit"
+      else
+        puts "Loading #{Rails.env} environment (Rails #{Rails.version})"
+      end
+      IRB.start
+    end
+  end
+end
+
+# Has to set the RAILS_ENV before config/application is required
+if ARGV.first && !ARGV.first.index("-") && env = ARGV.pop # has to pop the env ARGV so IRB doesn't freak
+  ENV['RAILS_ENV'] = %w(production development test).find { |e| e.index(env) } || env
+end

data/lib/rails/commands/dbconsole.rb

@@ -0,0 +1,104 @@
+require 'erb'
+require 'yaml'
+require 'optparse'
+
+module Rails
+  class DBConsole
+    def self.start(app)
+      new(app).start
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def start
+      include_password = false
+      options = {}
+      OptionParser.new do |opt|
+        opt.banner = "Usage: dbconsole [options] [environment]"
+        opt.on("-p", "--include-password", "Automatically provide the password from database.yml") do |v|
+          include_password = true
+        end
+
+        opt.on("--mode [MODE]", ['html', 'list', 'line', 'column'],
+          "Automatically put the sqlite3 database in the specified mode (html, list, line, column).") do |mode|
+            options['mode'] = mode
+        end
+
+        opt.on("-h", "--header") do |h|
+          options['header'] = h
+        end
+
+        opt.parse!(ARGV)
+        abort opt.to_s unless (0..1).include?(ARGV.size)
+      end
+
+      unless config = YAML::load(ERB.new(IO.read("#{@app.root}/config/database.yml")).result)[Rails.env]
+        abort "No database is configured for the environment '#{Rails.env}'"
+      end
+
+
+      def find_cmd(*commands)
+        dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
+        commands += commands.map{|cmd| "#{cmd}.exe"} if RUBY_PLATFORM =~ /win32/
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dir = dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            File.executable? full_path_command
+          end
+        end
+        found ? full_path_command : abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+      end
+
+      case config["adapter"]
+      when "mysql"
+        args = {
+          'host'      => '--host',
+          'port'      => '--port',
+          'socket'    => '--socket',
+          'username'  => '--user',
+          'encoding'  => '--default-character-set'
+        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
+
+        if config['password'] && include_password
+          args << "--password=#{config['password']}"
+        elsif config['password'] && !config['password'].to_s.empty?
+          args << "-p"
+        end
+
+        args << config['database']
+
+        exec(find_cmd('mysql', 'mysql5'), *args)
+
+      when "postgresql"
+        ENV['PGUSER']     = config["username"] if config["username"]
+        ENV['PGHOST']     = config["host"] if config["host"]
+        ENV['PGPORT']     = config["port"].to_s if config["port"]
+        ENV['PGPASSWORD'] = config["password"].to_s if config["password"] && include_password
+        exec(find_cmd('psql'), config["database"])
+
+      when "sqlite"
+        exec(find_cmd('sqlite'), config["database"])
+
+      when "sqlite3"
+        args = []
+
+        args << "-#{options['mode']}" if options['mode']
+        args << "-header" if options['header']
+        args << config['database']
+
+        exec(find_cmd('sqlite3'), *args)
+      else
+        abort "Unknown command-line client for #{config['database']}. Submit a Rails patch to add support!"
+      end
+    end
+  end
+end
+
+# Has to set the RAILS_ENV before config/application is required
+if ARGV.first && !ARGV.first.index("-") && env = ARGV.first
+  ENV['RAILS_ENV'] = %w(production development test).find { |e| e.index(env) } || env
+end