railties 3.2.22.5 → 4.0.0.beta1

data/lib/rails/code_statistics_calculator.rb

@@ -0,0 +1,79 @@
+class CodeStatisticsCalculator #:nodoc:
+  attr_reader :lines, :code_lines, :classes, :methods
+
+  PATTERNS = {
+    rb: {
+      line_comment: /^\s*#/,
+      begin_block_comment: /^=begin/,
+      end_block_comment: /^=end/,
+      class: /^\s*class\s+[_A-Z]/,
+      method: /^\s*def\s+[_a-z]/,
+    },
+    js: {
+      line_comment: %r{^\s*//},
+      begin_block_comment: %r{^\s*/\*},
+      end_block_comment: %r{\*/},
+      method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+    },
+    coffee: {
+      line_comment: /^\s*#/,
+      begin_block_comment: /^\s*###/,
+      end_block_comment: /^\s*###/,
+      class: /^\s*class\s+[_A-Z]/,
+      method: /[-=]>/,
+    }
+  }
+
+  def initialize(lines = 0, code_lines = 0, classes = 0, methods = 0)
+    @lines = lines
+    @code_lines = code_lines
+    @classes = classes
+    @methods = methods
+  end
+
+  def add(code_statistics_calculator)
+    @lines += code_statistics_calculator.lines
+    @code_lines += code_statistics_calculator.code_lines
+    @classes += code_statistics_calculator.classes
+    @methods += code_statistics_calculator.methods
+  end
+
+  def add_by_file_path(file_path)
+    File.open(file_path) do |f|
+      self.add_by_io(f, file_type(file_path))
+    end
+  end
+
+  def add_by_io(io, file_type)
+    patterns = PATTERNS[file_type] || {}
+
+    comment_started = false
+
+    while line = io.gets
+      @lines += 1
+
+      if comment_started
+        if patterns[:end_block_comment] && line =~ patterns[:end_block_comment]
+          comment_started = false
+        end
+        next
+      else
+        if patterns[:begin_block_comment] && line =~ patterns[:begin_block_comment]
+          comment_started = true
+          next
+        end
+      end
+
+      @classes   += 1 if patterns[:class] && line =~ patterns[:class]
+      @methods   += 1 if patterns[:method] && line =~ patterns[:method]
+      if line !~ /^\s*$/ && (patterns[:line_comment].nil? || line !~ patterns[:line_comment])
+        @code_lines += 1
+      end
+    end
+  end
+
+  private
+    def file_type(file_path)
+      File.extname(file_path).sub(/\A\./, '').downcase.to_sym
+    end
+end

data/lib/rails/commands.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/object/inclusion'
-
 ARGV << '--help' if ARGV.empty?
 
 aliases = {
@@ -11,6 +9,28 @@ aliases = {
   "r"  => "runner"
 }
 
+help_message = <<-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")
+ new         Create a new Rails application. "rails new my_app" creates a
+             new application called MyApp in "./my_app"
+
+In addition to those, there are:
+ application  Generate the Rails application code
+ destroy      Undo code generated with "generate" (short-cut alias: "d")
+ plugin new   Generates skeleton for developing a Rails plugin
+ runner       Run a piece of code in the application environment (short-cut alias: "r")
+
+All commands can be run with -h (or --help) for more information.
+EOT
+
+
 command = ARGV.shift
 command = aliases[command] || command
 
@@ -29,42 +49,44 @@ when 'generate', 'destroy', 'plugin'
     require "rails/commands/#{command}"
   end
 
-when 'benchmarker', 'profiler'
-  require APP_PATH
-  Rails.application.require_environment!
-  require "rails/commands/#{command}"
-
 when 'console'
   require 'rails/commands/console'
+  options = Rails::Console.parse_arguments(ARGV)
+
+  # RAILS_ENV needs to be set before config/application is required
+  ENV['RAILS_ENV'] = options[:environment] if options[:environment]
+
+  # shift ARGV so IRB doesn't freak
+  ARGV.shift if ARGV.first && ARGV.first[0] != '-'
+
   require APP_PATH
   Rails.application.require_environment!
-  Rails::Console.start(Rails.application)
+  Rails::Console.start(Rails.application, options)
 
 when 'server'
   # Change to the application's path if there is no config.ru file in current dir.
-  # This allows us to run script/rails server from other directories, but still get
+  # This allows us to run `rails server` from other directories, but still get
   # the main config.ru and properly set the tmp directory.
   Dir.chdir(File.expand_path('../../', APP_PATH)) unless File.exists?(File.expand_path("config.ru"))
 
   require 'rails/commands/server'
-  Rails::Server.new.tap { |server|
+  Rails::Server.new.tap do |server|
     # We need to require application after the server sets environment,
     # otherwise the --environment option given to the server won't propagate.
     require APP_PATH
     Dir.chdir(Rails.application.root)
     server.start
-  }
+  end
 
 when 'dbconsole'
   require 'rails/commands/dbconsole'
-  require APP_PATH
-  Rails::DBConsole.start(Rails.application)
+  Rails::DBConsole.start
 
 when 'application', 'runner'
   require "rails/commands/#{command}"
 
 when 'new'
-  if ARGV.first.in?(['-h', '--help'])
+  if %w(-h --help).include?(ARGV.first)
     require 'rails/commands/application'
   else
     puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
@@ -76,29 +98,14 @@ when '--version', '-v'
   ARGV.unshift '--version'
   require 'rails/commands/application'
 
-else
-  puts "Error: Command not recognized" unless command.in?(['-h', '--help'])
-  puts <<-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")
- new         Create a new Rails application. "rails new my_app" creates a
-             new application called MyApp in "./my_app"
-
-In addition to those, there are:
- application  Generate the Rails application code
- destroy      Undo code generated with "generate" (short-cut alias: "d")
- 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 (short-cut alias: "r")
+when '-h', '--help'
+  puts help_message
 
-All commands can be run with -h (or --help) for more information.
-  EOT
+else
+  puts "Error: Command '#{command}' not recognized"
+  if %x{rake #{command} --dry-run 2>&1 } && $?.success?
+    puts "Did you mean: `$ rake #{command}` ?\n\n"
+  end
+  puts help_message
   exit(1)
 end

data/lib/rails/commands/application.rb

@@ -9,23 +9,28 @@ if ARGV.first != "new"
   ARGV[0] = "--help"
 else
   ARGV.shift
-  railsrc = File.join(File.expand_path("~"), ".railsrc")
-  if File.exist?(railsrc)
-    extra_args_string = File.open(railsrc).read
-    extra_args = extra_args_string.split(/\n+/).map {|l| l.split}.flatten
-    puts "Using #{extra_args.join(" ")} from #{railsrc}"
-    ARGV << extra_args
-    ARGV.flatten!
+  unless ARGV.delete("--no-rc")
+    customrc = ARGV.index{ |x| x.include?("--rc=") }
+    railsrc = if customrc
+                File.expand_path(ARGV.delete_at(customrc).gsub(/--rc=/, ""))
+              else
+                File.join(File.expand_path("~"), '.railsrc')
+              end
+    if File.exist?(railsrc)
+      extra_args_string = File.read(railsrc)
+      extra_args = extra_args_string.split(/\n+/).map {|l| l.split}.flatten
+      puts "Using #{extra_args.join(" ")} from #{railsrc}"
+      ARGV.insert(1, *extra_args)
+    end
   end
 end
 
-require 'rubygems' if ARGV.include?("--dev")
 require 'rails/generators'
 require 'rails/generators/rails/app/app_generator'
 
 module Rails
   module Generators
-    class AppGenerator
+    class AppGenerator # :nodoc:
       # We want to exit on failure to be kind to other libraries
       # This is only when accessing via CLI
       def self.exit_on_failure?

data/lib/rails/commands/console.rb

@@ -4,52 +4,96 @@ require 'irb/completion'
 
 module Rails
   class Console
-    def self.start(app)
-      new(app).start
-    end
+    class << self
+      def start(*args)
+        new(*args).start
+      end
 
-    def initialize(app)
-      @app = app
-    end
+      def parse_arguments(arguments)
+        options = {}
 
-    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', "DEPRECATED: Invoke `/your/choice/of/ruby script/rails console` instead") { |v| abort '--irb option is no longer supported. Invoke `/your/choice/of/ruby script/rails console` instead' }
-        opt.parse!(ARGV)
+        OptionParser.new do |opt|
+          opt.banner = "Usage: rails console [environment] [options]"
+          opt.on('-s', '--sandbox', 'Rollback database modifications on exit.') { |v| options[:sandbox] = v }
+          opt.on("-e", "--environment=name", String,
+                  "Specifies the environment to run this console under (test/development/production).",
+                  "Default: development") { |v| options[:environment] = v.strip }
+          opt.on("--debugger", 'Enable the debugger.') { |v| options[:debugger] = v }
+          opt.parse!(arguments)
+        end
+
+        if arguments.first && arguments.first[0] != '-'
+          env = arguments.first
+          if available_environments.include? env
+            options[:environment] = env
+          else
+            options[:environment] = %w(production development test).detect {|e| e =~ /^#{env}/} || env
+          end
+        end
+
+        options
       end
 
-      @app.sandbox = options[:sandbox]
-      @app.load_console
+      private
 
-      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
+        def available_environments
+          Dir['config/environments/*.rb'].map { |fname| File.basename(fname, '.*') }
         end
-      end
+    end
+
+    attr_reader :options, :app, :console
+
+    def initialize(app, options={})
+      @app     = app
+      @options = options
+      app.load_console
+      @console = app.config.console || IRB
+    end
+
+    def sandbox?
+      options[:sandbox]
+    end
 
-      if options[:sandbox]
+    def environment
+      options[:environment] ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    def environment?
+      environment
+    end
+
+    def set_environment!
+      Rails.env = environment
+    end
+
+    def debugger?
+      options[:debugger]
+    end
+
+    def start
+      app.sandbox = sandbox?
+      require_debugger if debugger?
+      set_environment! if environment?
+
+      if 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::ExtendCommandBundle.send :include, Rails::ConsoleMethods
-      IRB.start
+      if defined?(console::ExtendCommandBundle)
+        console::ExtendCommandBundle.send :include, Rails::ConsoleMethods
+      end
+      console.start
     end
-  end
-end
 
-# Has to set the RAILS_ENV before config/application is required
-if ARGV.first && !ARGV.first.index("-") && env = ARGV.shift # has to shift the env ARGV so IRB doesn't freak
-  ENV['RAILS_ENV'] = %w(production development test).detect {|e| e =~ /^#{env}/} || env
+    def require_debugger
+      require 'debugger'
+      puts "=> Debugger enabled"
+    rescue LoadError
+      puts "You're missing the 'debugger' gem. Add it to your Gemfile, bundle, and try again."
+      exit
+    end
+  end
 end

data/lib/rails/commands/dbconsole.rb

@@ -1,64 +1,23 @@
 require 'erb'
-
-begin
-  require 'psych'
-rescue LoadError
-end
-
 require 'yaml'
 require 'optparse'
 require 'rbconfig'
 
 module Rails
   class DBConsole
-    def self.start(app)
-      new(app).start
+    attr_reader :arguments
+
+    def self.start
+      new.start
     end
 
-    def initialize(app)
-      @app = app
+    def initialize(arguments = ARGV)
+      @arguments = arguments
     end
 
     def start
-      include_password = false
-      options = {}
-      OptionParser.new do |opt|
-        opt.banner = "Usage: dbconsole [environment] [options]"
-        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("--header") do |h|
-          options['header'] = h
-        end
-
-        opt.parse!(ARGV)
-        abort opt.to_s unless (0..1).include?(ARGV.size)
-      end
-
-      unless config = @app.config.database_configuration[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 RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-
-        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
+      options = parse_arguments(arguments)
+      ENV['RAILS_ENV'] = options[:environment] || environment
 
       case config["adapter"]
       when /^mysql/
@@ -67,10 +26,15 @@ module Rails
           'port'      => '--port',
           'socket'    => '--socket',
           'username'  => '--user',
-          'encoding'  => '--default-character-set'
+          'encoding'  => '--default-character-set',
+          'sslca'     => '--ssl-ca',
+          'sslcert'   => '--ssl-cert',
+          'sslcapath' => '--ssl-capath',
+          'sslcipher' => '--ssh-cipher',
+          'sslkey'    => '--ssl-key'
         }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
 
-        if config['password'] && include_password
+        if config['password'] && options['include_password']
           args << "--password=#{config['password']}"
         elsif config['password'] && !config['password'].to_s.empty?
           args << "-p"
@@ -78,46 +42,133 @@ module Rails
 
         args << config['database']
 
-        exec(find_cmd('mysql', 'mysql5'), *args)
+        find_cmd_and_exec(['mysql', 'mysql5'], *args)
 
       when "postgresql", "postgres"
         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"])
+        ENV['PGPASSWORD'] = config["password"].to_s if config["password"] && options['include_password']
+        find_cmd_and_exec('psql', config["database"])
 
       when "sqlite"
-        exec(find_cmd('sqlite'), config["database"])
+        find_cmd_and_exec('sqlite', config["database"])
 
       when "sqlite3"
         args = []
 
         args << "-#{options['mode']}" if options['mode']
         args << "-header" if options['header']
-        args << config['database']
+        args << File.expand_path(config['database'], Rails.respond_to?(:root) ? Rails.root : nil)
 
-        exec(find_cmd('sqlite3'), *args)
+        find_cmd_and_exec('sqlite3', *args)
 
       when "oracle", "oracle_enhanced"
         logon = ""
 
         if config['username']
           logon = config['username']
-          logon << "/#{config['password']}" if config['password'] && include_password
+          logon << "/#{config['password']}" if config['password'] && options['include_password']
           logon << "@#{config['database']}" if config['database']
         end
 
-        exec(find_cmd('sqlplus'), logon)
+        find_cmd_and_exec('sqlplus', logon)
 
       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).detect {|e| e =~ /^#{env}/} || env
+    def config
+      @config ||= begin
+        cfg = begin
+          YAML.load(ERB.new(IO.read("config/database.yml")).result)
+        rescue SyntaxError, StandardError
+          require APP_PATH
+          Rails.application.config.database_configuration
+        end
+
+        cfg[environment] || abort("No database is configured for the environment '#{environment}'")
+      end
+    end
+
+    def environment
+      if Rails.respond_to?(:env)
+        Rails.env
+      else
+        ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      end
+    end
+
+    protected
+
+    def parse_arguments(arguments)
+      options = {}
+
+      OptionParser.new do |opt|
+        opt.banner = "Usage: rails dbconsole [environment] [options]"
+        opt.on("-p", "--include-password", "Automatically provide the password from database.yml") do |v|
+          options['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("--header") do |h|
+          options['header'] = h
+        end
+
+        opt.on("-h", "--help", "Show this help message.") do
+          puts opt
+          exit
+        end
+
+        opt.on("-e", "--environment=name", String,
+          "Specifies the environment to run this console under (test/development/production).",
+          "Default: development"
+        ) { |v| options[:environment] = v.strip }
+
+        opt.parse!(arguments)
+        abort opt.to_s unless (0..1).include?(arguments.size)
+      end
+
+      if arguments.first && arguments.first[0] != '-'
+        env = arguments.first
+        if available_environments.include? env
+          options[:environment] = env
+        else
+          options[:environment] = %w(production development test).detect {|e| e =~ /^#{env}/} || env
+        end
+      end
+
+      options
+    end
+
+    def available_environments
+      Dir['config/environments/*.rb'].map { |fname| File.basename(fname, '.*') }
+    end
+
+    def find_cmd_and_exec(commands, *args)
+      commands = Array(commands)
+
+      dirs_on_path = ENV['PATH'].to_s.split(File::PATH_SEPARATOR)
+      commands += commands.map{|cmd| "#{cmd}.exe"} if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+
+      full_path_command = nil
+      found = commands.detect do |cmd|
+        dirs_on_path.detect do |path|
+          full_path_command = File.join(path, cmd)
+          File.executable? full_path_command
+        end
+      end
+
+      if found
+        exec full_path_command, *args
+      else
+        abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+      end
+    end
+  end
 end