Initial command structure.

15 files changed, 704 insertions, 0 deletions

diff --git a/railties/lib/rails/commands/application/application_command.rb b/railties/lib/rails/commands/application/application_command.rb
new file mode 100644
index 0000000000..7e3a2b011d
--- /dev/null
+++ b/railties/lib/rails/commands/application/application_command.rb
@@ -0,0 +1,29 @@
+require "rails/generators"
+require "rails/generators/rails/app/app_generator"
+
+module Rails
+  module Generators
+    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?
+        true
+      end
+    end
+  end
+
+  module Command
+    class ApplicationCommand < Base
+      hide_command!
+
+      def help
+        perform # Punt help output to the generator.
+      end
+
+      def perform(*args)
+        Rails::Generators::AppGenerator.start \
+          Rails::Generators::ARGVScrubber.new(args).prepare!
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/console/console_command.rb b/railties/lib/rails/commands/console/console_command.rb
new file mode 100644
index 0000000000..730b108d8c
--- /dev/null
+++ b/railties/lib/rails/commands/console/console_command.rb
@@ -0,0 +1,89 @@
+require "irb"
+require "irb/completion"
+
+require "rails/command/environment_argument"
+
+module Rails
+  class Console
+    module BacktraceCleaner
+      def filter_backtrace(bt)
+        if result = super
+          Rails.backtrace_cleaner.filter([result]).first
+        end
+      end
+    end
+
+    def self.start(*args)
+      new(*args).start
+    end
+
+    attr_reader :options, :app, :console
+
+    def initialize(app, options = {})
+      @app     = app
+      @options = options
+
+      app.sandbox = sandbox?
+      app.load_console
+
+      @console = app.config.console || IRB
+
+      if @console == IRB
+        IRB::WorkSpace.prepend(BacktraceCleaner)
+      end
+    end
+
+    def sandbox?
+      options[:sandbox]
+    end
+
+    def environment
+      options[:environment]
+    end
+    alias_method :environment?, :environment
+
+    def set_environment!
+      Rails.env = environment
+    end
+
+    def start
+      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
+
+      if defined?(console::ExtendCommandBundle)
+        console::ExtendCommandBundle.include(Rails::ConsoleMethods)
+      end
+      console.start
+    end
+  end
+
+  module Command
+    class ConsoleCommand < Base
+      include EnvironmentArgument
+
+      class_option :sandbox, aliases: "-s", type: :boolean, default: false,
+        desc: "Rollback database modifications on exit."
+
+      class_option :environment, aliases: "-e", type: :string, default: Rails::Command.environment,
+        desc: "Specifies the environment to run this console under (test/development/production)."
+
+      def perform
+        extract_environment_option_from_argument
+
+        # RAILS_ENV needs to be set before config/application is required.
+        ENV["RAILS_ENV"] = options[:environment]
+
+        ARGV.clear # Clear ARGV so IRB doesn't freak.
+
+        require_application_and_environment!
+        Rails::Console.start(Rails.application, options)
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/dbconsole/dbconsole_command.rb b/railties/lib/rails/commands/dbconsole/dbconsole_command.rb
new file mode 100644
index 0000000000..021714f61d
--- /dev/null
+++ b/railties/lib/rails/commands/dbconsole/dbconsole_command.rb
@@ -0,0 +1,160 @@
+require "erb"
+require "yaml"
+
+require "rails/command/environment_argument"
+
+module Rails
+  class DBConsole
+    attr_reader :arguments
+
+    def self.start(*args)
+      new(*args).start
+    end
+
+    def initialize(arguments = ARGV, options = {})
+      @arguments, @options = arguments, options
+    end
+
+    def start
+      ENV["RAILS_ENV"] = @options[:environment] || environment
+
+      case config["adapter"]
+      when /^(jdbc)?mysql/
+        args = {
+          "host"      => "--host",
+          "port"      => "--port",
+          "socket"    => "--socket",
+          "username"  => "--user",
+          "encoding"  => "--default-character-set",
+          "sslca"     => "--ssl-ca",
+          "sslcert"   => "--ssl-cert",
+          "sslcapath" => "--ssl-capath",
+          "sslcipher" => "--ssl-cipher",
+          "sslkey"    => "--ssl-key"
+        }.map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }.compact
+
+        if config["password"] && @options["include_password"]
+          args << "--password=#{config['password']}"
+        elsif config["password"] && !config["password"].to_s.empty?
+          args << "-p"
+        end
+
+        args << config["database"]
+
+        find_cmd_and_exec(["mysql", "mysql5"], *args)
+
+      when /^postgres|^postgis/
+        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"] && @options["include_password"]
+        find_cmd_and_exec("psql", config["database"])
+
+      when "sqlite3"
+        args = []
+
+        args << "-#{@options['mode']}" if @options["mode"]
+        args << "-header" if @options["header"]
+        args << File.expand_path(config["database"], Rails.respond_to?(:root) ? Rails.root : nil)
+
+        find_cmd_and_exec("sqlite3", *args)
+
+      when "oracle", "oracle_enhanced"
+        logon = ""
+
+        if config["username"]
+          logon = config["username"]
+          logon << "/#{config['password']}" if config["password"] && @options["include_password"]
+          logon << "@#{config['database']}" if config["database"]
+        end
+
+        find_cmd_and_exec("sqlplus", logon)
+
+      when "sqlserver"
+        args = []
+
+        args += ["-D", "#{config['database']}"] if config["database"]
+        args += ["-U", "#{config['username']}"] if config["username"]
+        args += ["-P", "#{config['password']}"] if config["password"]
+
+        if config["host"]
+          host_arg = "#{config['host']}"
+          host_arg << ":#{config['port']}" if config["port"]
+          args += ["-S", host_arg]
+        end
+
+        find_cmd_and_exec("sqsh", *args)
+
+      else
+        abort "Unknown command-line client for #{config['database']}."
+      end
+    end
+
+    def config
+      @config ||= begin
+        if configurations[environment].blank?
+          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
+        else
+          configurations[environment]
+        end
+      end
+    end
+
+    def environment
+      Rails.respond_to?(:env) ? Rails.env : Rails::Command.environment
+    end
+
+    protected
+      def configurations
+        require APP_PATH
+        ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+        ActiveRecord::Base.configurations
+      end
+
+      def find_cmd_and_exec(commands, *args)
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        end
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            File.file?(full_path_command) && 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
+
+  module Command
+    class DbconsoleCommand < Base
+      include EnvironmentArgument
+
+      class_option :include_password, aliases: "-p", type: :boolean,
+        desc: "Automatically provide the password from database.yml"
+
+      class_option :mode, enum: %w( html list line column ), type: :string,
+        desc: "Automatically put the sqlite3 database in the specified mode (html, list, line, column)."
+
+      class_option :header, type: :string
+
+      class_option :environment, aliases: "-e", type: :string, default: Rails::Command.environment,
+        desc: "Specifies the environment to run this console under (test/development/production)."
+
+      def perform
+        extract_environment_option_from_argument
+
+        Rails::DBConsole.start(args, options)
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/destroy/destroy_command.rb b/railties/lib/rails/commands/destroy/destroy_command.rb
new file mode 100644
index 0000000000..5e6b7f9371
--- /dev/null
+++ b/railties/lib/rails/commands/destroy/destroy_command.rb
@@ -0,0 +1,21 @@
+require "rails/generators"
+
+module Rails
+  module Command
+    class DestroyCommand < Base
+      def help # :nodoc:
+        Rails::Generators.help self.class.command_name
+      end
+
+      def perform(*)
+        generator = args.shift
+        return help unless generator
+
+        require_application_and_environment!
+        Rails.application.load_generators
+
+        Rails::Generators.invoke generator, args, behavior: :revoke, destination_root: Rails.root
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/generate/generate_command.rb b/railties/lib/rails/commands/generate/generate_command.rb
new file mode 100644
index 0000000000..b381ca85b9
--- /dev/null
+++ b/railties/lib/rails/commands/generate/generate_command.rb
@@ -0,0 +1,21 @@
+require "rails/generators"
+
+module Rails
+  module Command
+    class GenerateCommand < Base
+      def help # :nodoc:
+        Rails::Generators.help self.class.command_name
+      end
+
+      def perform(*)
+        generator = args.shift
+        return help unless generator
+
+        require_application_and_environment!
+        load_generators
+
+        Rails::Generators.invoke generator, args, behavior: :invoke, destination_root: Rails::Command.root
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/help/USAGE b/railties/lib/rails/commands/help/USAGE
new file mode 100644
index 0000000000..0f6ff756ce
--- /dev/null
+++ b/railties/lib/rails/commands/help/USAGE
@@ -0,0 +1,16 @@
+Usage: bin/rails COMMAND [args] [options]
+
+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")
+ test        Run tests (short-cut alias: "t")
+ 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"
+
+All commands can be run with -h (or --help) for more information.
+
+In addition to those commands, there are:
+
diff --git a/railties/lib/rails/commands/help/help_command.rb b/railties/lib/rails/commands/help/help_command.rb
new file mode 100644
index 0000000000..5bcc4c8eee
--- /dev/null
+++ b/railties/lib/rails/commands/help/help_command.rb
@@ -0,0 +1,13 @@
+module Rails
+  module Command
+    class HelpCommand < Base
+      hide_command!
+
+      def help(*)
+        puts self.class.desc
+
+        Rails::Command.print_commands
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/new/new_command.rb b/railties/lib/rails/commands/new/new_command.rb
new file mode 100644
index 0000000000..13eedfc479
--- /dev/null
+++ b/railties/lib/rails/commands/new/new_command.rb
@@ -0,0 +1,15 @@
+module Rails
+  module Command
+    class NewCommand < Base
+      def help
+        Rails::Command.invoke :application, [ "--help" ]
+      end
+
+      def perform(*)
+        puts "Can't initialize a new Rails application within the directory of another, please change to a non-Rails directory first.\n"
+        puts "Type 'rails' for help."
+        exit 1
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/plugin/plugin_command.rb b/railties/lib/rails/commands/plugin/plugin_command.rb
new file mode 100644
index 0000000000..d6d9fe4400
--- /dev/null
+++ b/railties/lib/rails/commands/plugin/plugin_command.rb
@@ -0,0 +1,43 @@
+module Rails
+  module Command
+    class PluginCommand < Base
+      hide_command!
+
+      def help
+        run_plugin_generator %w( --help )
+      end
+
+      def self.banner(*) # :nodoc:
+        "#{executable} new [options]"
+      end
+
+      class_option :rc, type: :boolean, default: File.join("~", ".railsrc"),
+        desc: "Initialize the plugin command with previous defaults. Uses .railsrc in your home directory by default."
+
+      class_option :no_rc, desc: "Skip evaluating .railsrc."
+
+      def perform(type = nil, *plugin_args)
+        plugin_args << "--help" unless type == "new"
+
+        unless options.key?("no_rc") # Thor's not so indifferent access hash.
+          railsrc = File.expand_path(options[:rc])
+
+          if File.exist?(railsrc)
+            extra_args = File.read(railsrc).split(/\n+/).flat_map(&:split)
+            puts "Using #{extra_args.join(" ")} from #{railsrc}"
+            plugin_args.insert(1, *extra_args)
+          end
+        end
+
+        run_plugin_generator plugin_args
+      end
+
+      private
+        def run_plugin_generator(plugin_args)
+          require "rails/generators"
+          require "rails/generators/rails/plugin/plugin_generator"
+          Rails::Generators::PluginGenerator.start plugin_args
+        end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/rake/rake_command.rb b/railties/lib/rails/commands/rake/rake_command.rb
new file mode 100644
index 0000000000..a4a2464445
--- /dev/null
+++ b/railties/lib/rails/commands/rake/rake_command.rb
@@ -0,0 +1,49 @@
+module Rails
+  module Command
+    class RakeCommand < Base
+      namespace "rake"
+
+      class << self
+        def printing_commands
+          formatted_rake_tasks.map(&:first)
+        end
+
+        def perform(task, *)
+          require_rake
+
+          ARGV.unshift(task) # Prepend the task, so Rake knows how to run it.
+
+          Rake.application.standard_exception_handling do
+            Rake.application.init("rails")
+            Rake.application.load_rakefile
+            Rake.application.top_level
+          end
+        end
+
+        private
+          def rake_tasks
+            require_rake
+
+            return @rake_tasks if defined?(@rake_tasks)
+
+            ActiveSupport::Deprecation.silence do
+              Rails::Command.require_application_and_environment!
+            end
+
+            Rake::TaskManager.record_task_metadata = true
+            Rake.application.instance_variable_set(:@name, "rails")
+            Rails.application.load_tasks
+            @rake_tasks = Rake.application.tasks.select(&:comment)
+          end
+
+          def formatted_rake_tasks
+            rake_tasks.map { |t| [ t.name_with_args, t.comment ] }
+          end
+
+          def require_rake
+            require "rake" # Defer booting Rake until we know it's needed.
+          end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/runner/USAGE b/railties/lib/rails/commands/runner/USAGE
new file mode 100644
index 0000000000..dc47a35ff3
--- /dev/null
+++ b/railties/lib/rails/commands/runner/USAGE
@@ -0,0 +1,17 @@
+Examples:
+
+Run `puts Rails.env` after loading the app:
+
+  <%= executable %> 'puts Rails.env'
+
+Run the Ruby file located at `path/to/filename.rb` after loading the app:
+
+  <%= executable %> path/to/filename.rb
+
+<% if RbConfig::CONFIG['host_os'] !~ /mswin|mingw/ %>
+You can also use the runner command as a shebang line for your executables:
+
+  #!/usr/bin/env <%= File.expand_path(executable) %>
+
+  Product.all.each { |p| p.price *= 2 ; p.save! }
+<% end %>
diff --git a/railties/lib/rails/commands/runner/runner_command.rb b/railties/lib/rails/commands/runner/runner_command.rb
new file mode 100644
index 0000000000..8db6da8759
--- /dev/null
+++ b/railties/lib/rails/commands/runner/runner_command.rb
@@ -0,0 +1,45 @@
+module Rails
+  module Command
+    class RunnerCommand < Base
+      class_option :environment, aliases: "-e", type: :string,
+        default: Rails::Command.environment.dup,
+        desc: "The environment for the runner to operate under (test/development/production)"
+
+      def help
+        super
+        puts self.class.desc
+      end
+
+      def self.banner(*)
+        "#{super} [<'Some.ruby(code)'> | <filename.rb>]"
+      end
+
+      def perform(code_or_file = nil)
+        unless code_or_file
+          help
+          exit 1
+        end
+
+        ENV["RAILS_ENV"] = options[:environment]
+
+        require_application_and_environment!
+        Rails.application.load_runner
+
+        if File.exist?(code_or_file)
+          $0 = code_or_file
+          Kernel.load code_or_file
+        else
+          begin
+            eval(code_or_file, binding, __FILE__, __LINE__)
+          rescue SyntaxError, NameError => error
+            $stderr.puts "Please specify a valid ruby command or the path of a script to run."
+            $stderr.puts "Run '#{self.class.executable} -h' for help."
+            $stderr.puts
+            $stderr.puts error
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/server/server_command.rb b/railties/lib/rails/commands/server/server_command.rb
new file mode 100644
index 0000000000..b45805bddd
--- /dev/null
+++ b/railties/lib/rails/commands/server/server_command.rb
@@ -0,0 +1,159 @@
+require "fileutils"
+require "optparse"
+require "action_dispatch"
+require "rails"
+require "rails/dev_caching"
+
+module Rails
+  class Server < ::Rack::Server
+    class Options
+      DEFAULT_PID_PATH = File.expand_path("tmp/pids/server.pid").freeze
+
+      def parse!(args)
+        args, options = args.dup, {}
+
+        option_parser(options).parse! args
+
+        options[:log_stdout] = options[:daemonize].blank? && (options[:environment] || Rails.env) == "development"
+        options[:server]     = args.shift
+        options
+      end
+
+      def option_parser(options) # :nodoc:
+        OptionParser.new do |opts|
+          opts.banner = "Usage: rails server [mongrel, thin etc] [options]"
+
+          opts.separator ""
+          opts.separator "Options:"
+
+          opts.on("-p", "--port=port", Integer,
+                  "Runs Rails on the specified port.", "Default: 3000") { |v| options[:Port] = v }
+          opts.on("-b", "--binding=IP", String,
+                  "Binds Rails to the specified IP.", "Default: localhost") { |v| options[:Host] = v }
+          opts.on("-c", "--config=file", String,
+                  "Uses a custom rackup configuration.") { |v| options[:config] = v }
+          opts.on("-d", "--daemon", "Runs server as a Daemon.") { options[:daemonize] = true }
+          opts.on("-e", "--environment=name", String,
+                  "Specifies the environment to run this server under (test/development/production).",
+                  "Default: development") { |v| options[:environment] = v }
+          opts.on("-P", "--pid=pid", String,
+                  "Specifies the PID file.",
+                  "Default: tmp/pids/server.pid") { |v| options[:pid] = v }
+          opts.on("-C", "--[no-]dev-caching",
+                  "Specifies whether to perform caching in development.",
+                  "true or false") { |v| options[:caching] = v }
+
+          opts.separator ""
+
+          opts.on("-h", "--help", "Shows this help message.") { puts opts; exit }
+        end
+      end
+    end
+
+    def initialize(*)
+      super
+      set_environment
+    end
+
+    # TODO: this is no longer required but we keep it for the moment to support older config.ru files.
+    def app
+      @app ||= begin
+        app = super
+        app.respond_to?(:to_app) ? app.to_app : app
+      end
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def set_environment
+      ENV["RAILS_ENV"] ||= options[:environment]
+    end
+
+    def start
+      print_boot_information
+      trap(:INT) { exit }
+      create_tmp_directories
+      setup_dev_caching
+      log_to_stdout if options[:log_stdout]
+
+      super
+    ensure
+      # The '-h' option calls exit before @options is set.
+      # If we call 'options' with it unset, we get double help banners.
+      puts "Exiting" unless @options && options[:daemonize]
+    end
+
+    def middleware
+      Hash.new([])
+    end
+
+    def default_options
+      super.merge(        Port:               ENV.fetch("PORT", 3000).to_i,
+        DoNotReverseLookup: true,
+        environment:        (ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development").dup,
+        daemonize:          false,
+        caching:            nil,
+        pid:                Options::DEFAULT_PID_PATH,
+        restart_cmd:        restart_command)
+    end
+
+    private
+
+      def setup_dev_caching
+        if options[:environment] == "development"
+          Rails::DevCaching.enable_by_argument(options[:caching])
+        end
+      end
+
+      def print_boot_information
+        url = "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}"
+        puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
+        puts "=> Rails #{Rails.version} application starting in #{Rails.env} on #{url}"
+        puts "=> Run `rails server -h` for more startup options"
+      end
+
+      def create_tmp_directories
+        %w(cache pids sockets).each do |dir_to_make|
+          FileUtils.mkdir_p(File.join(Rails.root, "tmp", dir_to_make))
+        end
+      end
+
+      def log_to_stdout
+        wrapped_app # touch the app so the logger is set up
+
+        console = ActiveSupport::Logger.new(STDOUT)
+        console.formatter = Rails.logger.formatter
+        console.level = Rails.logger.level
+
+        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
+          Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
+        end
+      end
+
+      def restart_command
+        "bin/rails server #{ARGV.join(' ')}"
+      end
+  end
+
+  module Command
+    class ServerCommand < Base
+      def help # :nodoc:
+        puts Rails::Server::Options.new.option_parser(Hash.new)
+      end
+
+      def perform
+        set_application_directory!
+
+        Rails::Server.new.tap do |server|
+          # Require application after server sets environment to propagate
+          # the --environment option.
+          require APP_PATH
+          Dir.chdir(Rails.application.root)
+          server.start
+        end
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/test/test_command.rb b/railties/lib/rails/commands/test/test_command.rb
new file mode 100644
index 0000000000..395edca933
--- /dev/null
+++ b/railties/lib/rails/commands/test/test_command.rb
@@ -0,0 +1,18 @@
+require "rails/command"
+require "rails/test_unit/minitest_plugin"
+
+module Rails
+  module Command
+    class TestCommand < Base
+      def help # :nodoc:
+        perform # Hand over help printing to minitest.
+      end
+
+      def perform(*)
+        $LOAD_PATH << Rails::Command.root.join("test")
+
+        exit Minitest.run(ARGV)
+      end
+    end
+  end
+end
diff --git a/railties/lib/rails/commands/version/version_command.rb b/railties/lib/rails/commands/version/version_command.rb
new file mode 100644
index 0000000000..4f3fbfca1b
--- /dev/null
+++ b/railties/lib/rails/commands/version/version_command.rb
@@ -0,0 +1,9 @@
+module Rails
+  module Command
+    class VersionCommand < Base
+      def perform
+        Rails::Command.invoke :application, [ "--version" ]
+      end
+    end
+  end
+end