diff --git a/railties/lib/rails/commands/application.rb b/railties/lib/rails/commands/application.rb
deleted file mode 100644
index f6e7771cf39e6..0000000000000
--- a/railties/lib/rails/commands/application.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-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
-end
-
-args = Rails::Generators::ARGVScrubber.new(ARGV).prepare!
-Rails::Generators::AppGenerator.start args
diff --git a/railties/lib/rails/commands/commands_tasks.rb b/railties/lib/rails/commands/commands_tasks.rb
deleted file mode 100644
index 43f9dd38f3c59..0000000000000
--- a/railties/lib/rails/commands/commands_tasks.rb
+++ /dev/null
@@ -1,136 +0,0 @@
-require "rails/commands/rake_proxy"
-require "rails/commands/common_commands_tasks"
-require "active_support/core_ext/string/strip"
-
-module Rails
-  # This is a class which takes in a rails command and initiates the appropriate
-  # initiation sequence.
-  #
-  # Warning: This class mutates ARGV because some commands require manipulating
-  # it before they are run.
-  class CommandsTasks # :nodoc:
-    include Rails::RakeProxy
-    include Rails::CommonCommandsTasks
-
-    attr_reader :argv
-
-    ADDITIONAL_COMMANDS = [
-      [ "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")' ]
-    ]
-
-    def initialize(argv)
-      @argv = argv
-    end
-
-    def plugin
-      require_command!("plugin")
-    end
-
-    def console
-      require_command!("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
-      shift_argv!
-
-      require_application_and_environment!
-      Rails::Console.start(Rails.application, options)
-    end
-
-    def server
-      set_application_directory!
-      require_command!("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
-    end
-
-    def dbconsole
-      require_command!("dbconsole")
-      Rails::DBConsole.start
-    end
-
-    def runner
-      require_command!("runner")
-    end
-
-    def new
-      if %w(-h --help).include?(argv.first)
-        require_command!("application")
-      else
-        exit_with_initialization_warning!
-      end
-    end
-
-    private
-
-      def exit_with_initialization_warning!
-        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
-
-      def shift_argv!
-        argv.shift if argv.first && argv.first[0] != "-"
-      end
-
-      # Change to the application's path if there is no config.ru file in current directory.
-      # This allows us to run `rails server` from other directories, but still get
-      # the main config.ru and properly set the tmp directory.
-      def set_application_directory!
-        Dir.chdir(File.expand_path("../../", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
-      end
-
-      def commands
-        ADDITIONAL_COMMANDS + formatted_rake_tasks
-      end
-
-      def command_whitelist
-        %w(plugin generate destroy console server dbconsole runner new version help test)
-      end
-
-      def help_message
-        <<-EOT.strip_heredoc
-          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")
-           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:
-        EOT
-      end
-
-      def require_application_and_environment!
-        require APP_PATH
-        Rails.application.require_environment!
-      end
-
-      def load_tasks
-        Rails.application.load_tasks
-      end
-
-      def load_generators
-        Rails.application.load_generators
-      end
-  end
-end
diff --git a/railties/lib/rails/commands/common_commands_tasks.rb b/railties/lib/rails/commands/common_commands_tasks.rb
deleted file mode 100644
index c1484d7ae2022..0000000000000
--- a/railties/lib/rails/commands/common_commands_tasks.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-module Rails
-  module CommonCommandsTasks # :nodoc:
-    def run_command!(command)
-      command = parse_command(command)
-
-      if command_whitelist.include?(command)
-        send(command)
-      else
-        run_rake_task(command)
-      end
-    end
-
-    def generate
-      generate_or_destroy(:generate)
-    end
-
-    def destroy
-      generate_or_destroy(:destroy)
-    end
-
-    def test
-      require_command!("test")
-    end
-
-    def version
-      argv.unshift "--version"
-      require_command!("application")
-    end
-
-    def help
-      write_help_message
-      write_commands(commands)
-    end
-
-    private
-
-      def generate_or_destroy(command)
-        require "rails/generators"
-        require_application_and_environment!
-        load_generators
-        require_command!(command)
-      end
-
-      def require_command!(command)
-        require "rails/commands/#{command}"
-      end
-
-      def write_help_message
-        puts help_message
-      end
-
-      def write_commands(commands)
-        width = commands.map { |name, _| name.size }.max || 10
-        commands.each { |command| printf(" %-#{width}s   %s\n", *command) }
-      end
-
-      def parse_command(command)
-        case command
-        when "--version", "-v"
-          "version"
-        when "--help", "-h"
-          "help"
-        else
-          command
-        end
-      end
-  end
-end
diff --git a/railties/lib/rails/commands/console.rb b/railties/lib/rails/commands/console.rb
deleted file mode 100644
index e00887323e4f2..0000000000000
--- a/railties/lib/rails/commands/console.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-require "optparse"
-require "irb"
-require "irb/completion"
-require "rails/commands/console_helper"
-
-module Rails
-  class Console
-    include ConsoleHelper
-
-    module BacktraceCleaner
-      def filter_backtrace(bt)
-        if result = super
-          Rails.backtrace_cleaner.filter([result]).first
-        end
-      end
-    end
-
-    class << self
-      def parse_arguments(arguments)
-        options = {}
-
-        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.parse!(arguments)
-        end
-
-        set_options_env(arguments, options)
-      end
-    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] ||= super
-    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
-end
diff --git a/railties/lib/rails/commands/console_helper.rb b/railties/lib/rails/commands/console_helper.rb
deleted file mode 100644
index 0b7f1c42494ed..0000000000000
--- a/railties/lib/rails/commands/console_helper.rb
+++ /dev/null
@@ -1,34 +0,0 @@
-require "active_support/concern"
-
-module Rails
-  module ConsoleHelper # :nodoc:
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def start(*args)
-        new(*args).start
-      end
-
-      private
-        def set_options_env(arguments, options)
-          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
-    end
-
-    def environment
-      ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
-    end
-  end
-end
diff --git a/railties/lib/rails/commands/dbconsole.rb b/railties/lib/rails/commands/dbconsole.rb
deleted file mode 100644
index 66b7a14f16027..0000000000000
--- a/railties/lib/rails/commands/dbconsole.rb
+++ /dev/null
@@ -1,173 +0,0 @@
-require "erb"
-require "yaml"
-require "optparse"
-require "rails/commands/console_helper"
-
-module Rails
-  class DBConsole
-    include ConsoleHelper
-
-    attr_reader :arguments
-
-    class << self
-      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
-
-        set_options_env(arguments, options)
-      end
-    end
-
-    def initialize(arguments = ARGV)
-      @arguments = arguments
-    end
-
-    def start
-      options = self.class.parse_arguments(arguments)
-      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 : super
-    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
-end
diff --git a/railties/lib/rails/commands/destroy.rb b/railties/lib/rails/commands/destroy.rb
deleted file mode 100644
index 71c8c5e5268d1..0000000000000
--- a/railties/lib/rails/commands/destroy.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-require "rails/generators"
-
-#if no argument/-h/--help is passed to rails destroy command, then
-#it generates the help associated.
-if [nil, "-h", "--help"].include?(ARGV.first)
-  Rails::Generators.help "destroy"
-  exit
-end
-
-name = ARGV.shift
-Rails::Generators.invoke name, ARGV, behavior: :revoke, destination_root: Rails.root
diff --git a/railties/lib/rails/commands/generate.rb b/railties/lib/rails/commands/generate.rb
deleted file mode 100644
index ba6f14073e7b5..0000000000000
--- a/railties/lib/rails/commands/generate.rb
+++ /dev/null
@@ -1,13 +0,0 @@
-require "rails/generators"
-
-#if no argument/-h/--help is passed to rails generate command, then
-#it generates the help associated.
-if [nil, "-h", "--help"].include?(ARGV.first)
-  Rails::Generators.help "generate"
-  exit
-end
-
-name = ARGV.shift
-
-root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
-Rails::Generators.invoke name, ARGV, behavior: :invoke, destination_root: root
diff --git a/railties/lib/rails/commands/plugin.rb b/railties/lib/rails/commands/plugin.rb
deleted file mode 100644
index 60653a2ceeb68..0000000000000
--- a/railties/lib/rails/commands/plugin.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-if ARGV.first != "new"
-  ARGV[0] = "--help"
-else
-  ARGV.shift
-  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+/).flat_map(&:split)
-      puts "Using #{extra_args.join(" ")} from #{railsrc}"
-      ARGV.insert(1, *extra_args)
-    end
-  end
-end
-
-require "rails/generators"
-require "rails/generators/rails/plugin/plugin_generator"
-Rails::Generators::PluginGenerator.start
diff --git a/railties/lib/rails/commands/rake_proxy.rb b/railties/lib/rails/commands/rake_proxy.rb
deleted file mode 100644
index f8da71831a648..0000000000000
--- a/railties/lib/rails/commands/rake_proxy.rb
+++ /dev/null
@@ -1,41 +0,0 @@
-require "active_support"
-
-module Rails
-  module RakeProxy #:nodoc:
-    private
-      def run_rake_task(command)
-        require_rake
-
-        ARGV.unshift(command) # Prepend the command, 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
-
-      def rake_tasks
-        require_rake
-
-        return @rake_tasks if defined?(@rake_tasks)
-
-        ActiveSupport::Deprecation.silence do
-          require_application_and_environment!
-        end
-
-        Rake::TaskManager.record_task_metadata = true
-        Rake.application.instance_variable_set(:@name, "rails")
-        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
diff --git a/railties/lib/rails/commands/runner.rb b/railties/lib/rails/commands/runner.rb
deleted file mode 100644
index b74addf587640..0000000000000
--- a/railties/lib/rails/commands/runner.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-require "optparse"
-
-options = { environment: (ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development").dup }
-code_or_file = nil
-command = "bin/rails runner"
-
-if ARGV.first.nil?
-  ARGV.push "-h"
-end
-
-ARGV.clone.options do |opts|
-  opts.banner = "Usage: rails runner [options] [<'Some.ruby(code)'> | <filename.rb>]"
-
-  opts.separator ""
-
-  opts.on("-e", "--environment=name", String,
-          "Specifies the environment for the runner to operate under (test/development/production).",
-          "Default: development") { |v| options[:environment] = v }
-
-  opts.separator ""
-
-  opts.on("-h", "--help",
-          "Show this help message.") { $stdout.puts opts; exit }
-
-  opts.separator ""
-  opts.separator "Examples: "
-
-  opts.separator "    rails runner 'puts Rails.env'"
-  opts.separator "        This runs the code `puts Rails.env` after loading the app"
-  opts.separator ""
-  opts.separator "    rails runner path/to/filename.rb"
-  opts.separator "        This runs the Ruby file located at `path/to/filename.rb` after loading the app"
-
-  if RbConfig::CONFIG["host_os"] !~ /mswin|mingw/
-    opts.separator ""
-    opts.separator "You can also use runner as a shebang line for your executables:"
-    opts.separator "    -------------------------------------------------------------"
-    opts.separator "    #!/usr/bin/env #{File.expand_path(command)}"
-    opts.separator ""
-    opts.separator "    Product.all.each { |p| p.price *= 2 ; p.save! }"
-    opts.separator "    -------------------------------------------------------------"
-  end
-
-  opts.order! { |o| code_or_file ||= o } rescue retry
-end
-
-ARGV.delete(code_or_file)
-
-ENV["RAILS_ENV"] = options[:environment]
-
-require APP_PATH
-Rails.application.require_environment!
-Rails.application.load_runner
-
-if code_or_file.nil?
-  $stderr.puts "Run '#{command} -h' for help."
-  exit 1
-elsif 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 => e
-    $stderr.puts "Please specify a valid ruby command or the path of a script to run."
-    $stderr.puts "Run '#{command} -h' for help."
-    $stderr.puts
-    $stderr.puts e
-    exit 1
-  end
-end
diff --git a/railties/lib/rails/commands/server.rb b/railties/lib/rails/commands/server.rb
deleted file mode 100644
index 1eabf3fef3cf9..0000000000000
--- a/railties/lib/rails/commands/server.rb
+++ /dev/null
@@ -1,139 +0,0 @@
-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
-
-      private
-
-        def option_parser(options)
-          OptionParser.new do |opts|
-            opts.banner = "Usage: rails server [puma, thin etc] [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,
-        Host:               ENV.fetch("HOST", "localhost").dup,
-        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
-end
diff --git a/railties/lib/rails/commands/test.rb b/railties/lib/rails/commands/test.rb
deleted file mode 100644
index 56d1021fabc98..0000000000000
--- a/railties/lib/rails/commands/test.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-require "rails/test_unit/minitest_plugin"
-
-if defined?(ENGINE_ROOT)
-  $LOAD_PATH << File.expand_path("test", ENGINE_ROOT)
-else
-  $LOAD_PATH << File.expand_path("../../test", APP_PATH)
-end
-
-Minitest.run_via[:rails] = true
-
-require "active_support/testing/autorun"
diff --git a/railties/lib/rails/engine/commands_tasks.rb b/railties/lib/rails/engine/commands_tasks.rb
deleted file mode 100644
index 65dd27479371a..0000000000000
--- a/railties/lib/rails/engine/commands_tasks.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-require "rails/commands/rake_proxy"
-require "rails/commands/common_commands_tasks"
-require "active_support/core_ext/string/strip"
-
-module Rails
-  class Engine
-    class CommandsTasks # :nodoc:
-      include Rails::RakeProxy
-      include Rails::CommonCommandsTasks
-
-      attr_reader :argv
-
-      def initialize(argv)
-        @argv = argv
-      end
-
-      private
-
-        def commands
-          formatted_rake_tasks
-        end
-
-        def command_whitelist
-          %w(generate destroy version help test)
-        end
-
-        def help_message
-          <<-EOT.strip_heredoc
-            Usage: bin/rails COMMAND [ARGS]
-
-            The common Rails commands available for engines are:
-             generate    Generate new code (short-cut alias: "g")
-             destroy     Undo code generated with "generate" (short-cut alias: "d")
-             test        Run tests (short-cut alias: "t")
-
-            All commands can be run with -h for more information.
-
-            If you want to run any commands that need to be run in context
-            of the application, like `rails server` or `rails console`,
-            you should do it from application's directory (typically test/dummy).
-
-            In addition to those commands, there are:
-          EOT
-        end
-
-        def require_application_and_environment!
-          require ENGINE_PATH
-        end
-
-        def load_tasks
-          Rake.application.init("rails")
-          Rake.application.load_rakefile
-        end
-
-        def load_generators
-          engine = ::Rails::Engine.find(ENGINE_ROOT)
-          Rails::Generators.namespace = engine.railtie_namespace
-          engine.load_generators
-        end
-    end
-  end
-end