railties 7.0.8.7 → 7.1.5.1

data/lib/rails/commands/dbconsole/dbconsole_command.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/filters"
-require "active_support/deprecation"
 require "rails/command/environment_argument"
 
 module Rails
@@ -12,86 +11,13 @@ module Rails
 
     def initialize(options = {})
       @options = options
+      @options[:environment] ||= Rails::Command.environment
     end
 
     def start
-      ENV["RAILS_ENV"] ||= @options[:environment] || environment
-      config = db_config.configuration_hash
-
-      case db_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"
-        }.filter_map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }
-
-        if config[:password] && @options[:include_password]
-          args << "--password=#{config[:password]}"
-        elsif config[:password] && !config[:password].to_s.empty?
-          args << "-p"
-        end
-
-        args << db_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]
-        ENV["PGSSLMODE"]      = config[:sslmode].to_s if config[:sslmode]
-        ENV["PGSSLCERT"]      = config[:sslcert].to_s if config[:sslcert]
-        ENV["PGSSLKEY"]       = config[:sslkey].to_s if config[:sslkey]
-        ENV["PGSSLROOTCERT"]  = config[:sslrootcert].to_s if config[:sslrootcert]
-        find_cmd_and_exec("psql", db_config.database)
-
-      when "sqlite3"
-        args = []
-
-        args << "-#{@options[:mode]}" if @options[:mode]
-        args << "-header" if @options[:header]
-        args << File.expand_path(db_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].dup
-          logon << "/#{config[:password]}" if config[:password] && @options[:include_password]
-          logon << "@#{db_config.database}" if db_config.database
-        end
-
-        find_cmd_and_exec("sqlplus", logon)
-
-      when "sqlserver"
-        args = []
-
-        args += ["-d", "#{db_config.database}"] if db_config.database
-        args += ["-U", "#{config[:username]}"] if config[:username]
-        args += ["-P", "#{config[:password]}"] if config[:password]
-
-        if config[:host]
-          host_arg = +"tcp:#{config[:host]}"
-          host_arg << ",#{config[:port]}" if config[:port]
-          args += ["-S", host_arg]
-        end
-
-        find_cmd_and_exec("sqlcmd", *args)
-
-      else
-        abort "Unknown command-line client for #{db_config.database}."
-      end
+      adapter_class.dbconsole(db_config, @options)
+    rescue NotImplementedError
+      abort "Unknown command-line client for #{db_config.database}."
     end
 
     def db_config
@@ -114,15 +40,23 @@ module Rails
       @db_config
     end
 
-    def environment
-      Rails.respond_to?(:env) ? Rails.env : Rails::Command.environment
-    end
-
     def database
       @options[:database]
     end
 
+    def environment
+      @options[:environment]
+    end
+
     private
+      def adapter_class
+        if ActiveRecord::Base.respond_to?(db_config.adapter_class_method)
+          ActiveRecord::Base.public_send(db_config.adapter_class_method)
+        else
+          ActiveRecord::ConnectionAdapters::AbstractAdapter
+        end
+      end
+
       def configurations # :doc:
         require APP_PATH
         ActiveRecord::Base.configurations = Rails.application.config.database_configuration
@@ -130,31 +64,11 @@ module Rails
       end
 
       def find_cmd_and_exec(commands, *args) # :doc:
-        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)
-            begin
-              stat = File.stat(full_path_command)
-            rescue SystemCallError
-            else
-              stat.file? && stat.executable?
-            end
-          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
+        Rails.deprecator.warn(<<~MSG.squish)
+          Rails::DBConsole#find_cmd_and_exec is deprecated and will be removed in Rails 7.2.
+          Please use find_cmd_and_exec on the connection adapter class instead.
+        MSG
+        ActiveRecord::Base.connection.find_cmd_and_exec(commands, *args)
       end
   end
 
@@ -166,20 +80,16 @@ module Rails
         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)."
+        desc: "Automatically put the sqlite3 database in the specified mode"
 
       class_option :header, type: :boolean
 
       class_option :database, aliases: "--db", type: :string,
-        desc: "Specifies the database to use."
+        desc: "Specify the database to use."
 
+      desc "dbconsole", "Start a console for the database specified in config/database.yml"
       def perform
-        extract_environment_option_from_argument
-
-        # RAILS_ENV needs to be set before config/application is required.
-        ENV["RAILS_ENV"] = options[:environment]
-
-        require_application_and_environment!
+        boot_application!
         Rails::DBConsole.start(options)
       end
     end

data/lib/rails/commands/destroy/destroy_command.rb

@@ -7,18 +7,19 @@ module Rails
     class DestroyCommand < Base # :nodoc:
       no_commands do
         def help
-          require_application_and_environment!
+          boot_application!
           load_generators
 
           Rails::Generators.help self.class.command_name
         end
       end
 
+      desc "destroy GENERATOR", "Remove code generated by `bin/rails generate`"
       def perform(*)
         generator = args.shift
         return help unless generator
 
-        require_application_and_environment!
+        boot_application!
         load_generators
 
         Rails::Generators.invoke generator, args, behavior: :revoke, destination_root: Rails::Command.root

data/lib/rails/commands/dev/dev_command.rb

@@ -5,12 +5,7 @@ require "rails/dev_caching"
 module Rails
   module Command
     class DevCommand < Base # :nodoc:
-      no_commands do
-        def help
-          say "rails dev:cache # Toggle development mode caching on/off."
-        end
-      end
-
+      desc "cache", "Toggle development mode caching on/off"
       def cache
         Rails::DevCaching.enable_by_file
       end

data/lib/rails/commands/encrypted/USAGE

@@ -1,28 +1,23 @@
-=== Storing Encrypted Files in Source Control
+Description: 
+    The Rails `encrypted` commands provide access to encrypted files or configurations.
+    See the `Rails.application.encrypted` documentation for using them in your app.
 
-The Rails `encrypted` commands provide access to encrypted files or configurations.
-See the `Rails.application.encrypted` documentation for using them in your app.
+Encryption Keys:
+    By default, Rails looks for the encryption key in `ENV["RAILS_MASTER_KEY"]` or
+    `config/master.key`, but that lookup can be overridden with `--key`:
 
-=== Encryption Keys
+        <%= executable(:edit) %> config/encrypted_file.yml.enc --key config/encrypted_file.key
 
-By default, Rails looks for the encryption key in `config/master.key` or
-`ENV["RAILS_MASTER_KEY"]`, but that lookup can be overridden with `--key`:
+    Don't commit the key! Add it to your source control's ignore file. If you use
+    Git, Rails handles this for you.
 
-   rails encrypted:edit config/encrypted_file.yml.enc --key config/encrypted_file.key
+Examples:
+    To edit or create an encrypted file use:
 
-Don't commit the key! Add it to your source control's ignore file. If you use
-Git, Rails handles this for you.
+        <%= executable(:edit) %> config/encrypted_file.yml.enc
 
-=== Editing Files
+    This opens a temporary file in `$VISUAL` or `$EDITOR` with the decrypted contents for editing.
 
-To edit or create an encrypted file use:
+    To print the decrypted contents of an encrypted file use:
 
-   rails encrypted:edit config/encrypted_file.yml.enc
-
-This opens a temporary file in `$EDITOR` with the decrypted contents for editing.
-
-=== Viewing Files
-
-To print the decrypted contents of an encrypted file use:
-
-   rails encrypted:show config/encrypted_file.yml.enc
+        <%= executable(:show) %> config/encrypted_file.yml.enc

data/lib/rails/commands/encrypted/encrypted_command.rb

@@ -12,54 +12,65 @@ module Rails
       class_option :key, aliases: "-k", type: :string,
         default: "config/master.key", desc: "The Rails.root relative path to the encryption key"
 
-      no_commands do
-        def help
-          say "Usage:\n  #{self.class.banner}"
-          say ""
-          say self.class.desc
-        end
-      end
-
-      def edit(file_path)
-        require_application!
-        encrypted = Rails.application.encrypted(file_path, key_path: options[:key])
+      desc "edit", "Open the decrypted file in `$VISUAL` or `$EDITOR` for editing"
+      def edit(*)
+        load_environment_config!
 
-        ensure_editor_available(command: "bin/rails encrypted:edit") || (return)
-        ensure_encryption_key_has_been_added(options[:key]) if encrypted.key.nil?
-        ensure_encrypted_file_has_been_added(file_path, options[:key])
+        ensure_encryption_key_has_been_added
+        ensure_encrypted_configuration_has_been_added
 
-        catch_editing_exceptions do
-          change_encrypted_file_in_system_editor(file_path, options[:key])
-        end
-
-        say "File encrypted and saved."
-      rescue ActiveSupport::MessageEncryptor::InvalidMessage
-        say "Couldn't decrypt #{file_path}. Perhaps you passed the wrong key?"
+        change_encrypted_configuration_in_system_editor
       end
 
-      def show(file_path)
-        require_application!
-        encrypted = Rails.application.encrypted(file_path, key_path: options[:key])
+      desc "show", "Show the decrypted contents of the file"
+      def show(*)
+        load_environment_config!
 
-        say encrypted.read.presence || missing_encrypted_message(key: encrypted.key, key_path: options[:key], file_path: file_path)
+        say encrypted_configuration.read.presence || missing_encrypted_configuration_message
       end
 
       private
-        def ensure_encryption_key_has_been_added(key_path)
+        def content_path
+          @content_path ||= args[0]
+        end
+
+        def key_path
+          options[:key]
+        end
+
+        def encrypted_configuration
+          @encrypted_configuration ||= Rails.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          return if encrypted_configuration.key?
           encryption_key_file_generator.add_key_file(key_path)
           encryption_key_file_generator.ignore_key_file(key_path)
         end
 
-        def ensure_encrypted_file_has_been_added(file_path, key_path)
-          encrypted_file_generator.add_encrypted_file_silently(file_path, key_path)
+        def ensure_encrypted_configuration_has_been_added
+          encrypted_file_generator.add_encrypted_file_silently(content_path, key_path)
         end
 
-        def change_encrypted_file_in_system_editor(file_path, key_path)
-          Rails.application.encrypted(file_path, key_path: key_path).change do |tmp_path|
-            system("#{ENV["EDITOR"]} #{tmp_path}")
+        def change_encrypted_configuration_in_system_editor
+          using_system_editor do
+            encrypted_configuration.change { |tmp_path| system_editor(tmp_path) }
+            say "File encrypted and saved."
+            warn_if_encrypted_configuration_is_invalid
           end
+        rescue ActiveSupport::EncryptedFile::MissingKeyError => error
+          say error.message
+        rescue ActiveSupport::MessageEncryptor::InvalidMessage
+          say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
         end
 
+        def warn_if_encrypted_configuration_is_invalid
+          encrypted_configuration.validate!
+        rescue ActiveSupport::EncryptedConfiguration::InvalidContentError => error
+          say "WARNING: #{error.message}", :red
+          say ""
+          say "Your application will not be able to load '#{content_path}' until the error has been fixed.", :red
+        end
 
         def encryption_key_file_generator
           require "rails/generators"
@@ -75,11 +86,11 @@ module Rails
           Rails::Generators::EncryptedFileGenerator.new
         end
 
-        def missing_encrypted_message(key:, key_path:, file_path:)
-          if key.nil?
-            "Missing '#{key_path}' to decrypt data. See `bin/rails encrypted:help`"
+        def missing_encrypted_configuration_message
+          if !encrypted_configuration.key?
+            "Missing '#{key_path}' to decrypt data. See `#{executable(:help)}`"
           else
-            "File '#{file_path}' does not exist. Use `bin/rails encrypted:edit #{file_path}` to change that."
+            "File '#{content_path}' does not exist. Use `#{executable(:edit)} #{content_path}` to change that."
           end
         end
     end

data/lib/rails/commands/gem_help/USAGE

@@ -0,0 +1,16 @@
+Usage:
+  rails COMMAND [options]
+
+You must specify a command:
+
+  new          Create a new Rails application. "rails new my_app" creates a
+               new application called MyApp in "./my_app"
+  plugin new   Create a new Rails railtie or engine
+
+All commands can be run with -h (or --help) for more information.
+
+Inside a Rails application directory, some common commands are:
+
+  console      Start the Rails console
+  server       Start the Rails server
+  test         Run tests except system tests

data/lib/rails/commands/gem_help/gem_help_command.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class GemHelpCommand < Base # :nodoc:
+      hide_command!
+
+      def perform
+        say self.class.class_usage
+      end
+    end
+  end
+end

data/lib/rails/commands/generate/generate_command.rb

@@ -7,7 +7,7 @@ module Rails
     class GenerateCommand < Base # :nodoc:
       no_commands do
         def help
-          require_application_and_environment!
+          boot_application!
           load_generators
 
           Rails::Generators.help self.class.command_name
@@ -18,7 +18,7 @@ module Rails
         generator = args.shift
         return help unless generator
 
-        require_application_and_environment!
+        boot_application!
         load_generators
 
         ARGV.replace(args) # set up ARGV for third-party libraries

data/lib/rails/commands/help/USAGE

@@ -1,17 +1,17 @@
-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 except system tests (short-cut alias: "t")
- test:system  Run system tests
- dbconsole    Start a console for the database specified in config/database.yml
-              (short-cut alias: "db")
+Usage:
+  bin/rails COMMAND [options]
+
+You must specify a command. The most common 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 except system tests (short-cut alias: "t")
+  test:system  Run system tests
+  dbconsole    Start a console for the database specified in config/database.yml
+               (short-cut alias: "db")
 <% unless engine? -%>
- new          Create a new Rails application. "rails new my_app" creates a
-              new application called MyApp in "./my_app"
- plugin new   Create a new Rails railtie or engine
+  plugin new   Create a new Rails railtie or engine
 <% end -%>
 
 All commands can be run with -h (or --help) for more information.
-In addition to those commands, there are:
-

data/lib/rails/commands/help/help_command.rb

@@ -6,10 +6,29 @@ module Rails
       hide_command!
 
       def help(*)
-        say self.class.desc
+        say self.class.class_usage
+      end
+
+      def help_extended(*)
+        help
+
+        say ""
+        say "In addition to those commands, there are:"
+        say ""
 
-        Rails::Command.print_commands
+        extended_commands = printing_commands_not_in_usage.sort_by(&:first)
+        print_table(extended_commands, truncate: true)
       end
+
+      private
+        COMMANDS_IN_USAGE = %w(generate console server test test:system dbconsole new)
+        private_constant :COMMANDS_IN_USAGE
+
+        def printing_commands_not_in_usage # :nodoc:
+          Rails::Command.printing_commands.reject do |command, _|
+            command.in?(COMMANDS_IN_USAGE)
+          end
+        end
     end
   end
 end

data/lib/rails/commands/initializers/initializers_command.rb

@@ -9,10 +9,7 @@ module Rails
 
       desc "initializers", "Print out all defined initializers in the order they are invoked by Rails."
       def perform
-        extract_environment_option_from_argument
-        ENV["RAILS_ENV"] = options[:environment]
-
-        require_application_and_environment!
+        boot_application!
 
         Rails.application.initializers.tsort_each do |initializer|
           say "#{initializer.context_class}.#{initializer.name}"

data/lib/rails/commands/middleware/middleware_command.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class MiddlewareCommand < Base # :nodoc:
+      desc "middleware", "Print out your Rack middleware stack"
+      def perform
+        boot_application!
+
+        Rails.configuration.middleware.each do |middleware|
+          say "use #{middleware.inspect}"
+        end
+        say "run #{Rails.application.class.name}.routes"
+      end
+    end
+  end
+end

data/lib/rails/commands/new/new_command.rb

@@ -3,6 +3,8 @@
 module Rails
   module Command
     class NewCommand < Base # :nodoc:
+      self.bin = "rails"
+
       no_commands do
         def help
           Rails::Command.invoke :application, [ "--help" ]

data/lib/rails/commands/notes/notes_command.rb

@@ -7,8 +7,9 @@ module Rails
     class NotesCommand < Base # :nodoc:
       class_option :annotations, aliases: "-a", desc: "Filter by specific annotations, e.g. Foobar TODO", type: :array
 
+      desc "notes", "Show comments in your code annotated with FIXME, OPTIMIZE, and TODO"
       def perform(*)
-        require_application_and_environment!
+        boot_application!
 
         display_annotations
       end

data/lib/rails/commands/plugin/plugin_command.rb

@@ -5,6 +5,8 @@ module Rails
     class PluginCommand < Base # :nodoc:
       hide_command!
 
+      self.bin = "rails"
+
       def help
         run_plugin_generator %w( --help )
       end

data/lib/rails/commands/rake/rake_command.rb

@@ -9,42 +9,45 @@ module Rails
 
       class << self
         def printing_commands
-          formatted_rake_tasks.map(&:first)
+          rake_tasks.filter_map do |task|
+            if task.comment && task.locations.any?(non_app_file_pattern)
+              [task.name_with_args, task.comment]
+            end
+          end
         end
 
         def perform(task, args, config)
-          require_rake
-
-          Rake.with_application do |rake|
-            rake.init("rails", [task, *args])
-            rake.load_rakefile
-            if Rails.respond_to?(:root)
-              rake.options.suppress_backtrace_pattern = /\A(?!#{Regexp.quote(Rails.root.to_s)})/
+          with_rake(task, *args) do |rake|
+            if unrecognized_task = rake.top_level_tasks.find { |task| !rake.lookup(task[/[^\[]+/]) }
+              @rake_tasks = rake.tasks
+              raise UnrecognizedCommandError.new(unrecognized_task)
             end
+
+            rake.options.suppress_backtrace_pattern = non_app_file_pattern
             rake.standard_exception_handling { rake.top_level }
           end
         end
 
         private
-          def rake_tasks
-            require_rake
-
-            return @rake_tasks if defined?(@rake_tasks)
-
-            require_application!
+          def non_app_file_pattern
+            /\A(?!#{Regexp.quote Rails::Command.root.to_s})/
+          end
 
+          def with_rake(*args, &block)
+            require "rake"
             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 ] }
+            result = nil
+            Rake.with_application do |rake|
+              rake.init(bin, args) unless args.empty?
+              rake.load_rakefile
+              result = block.call(rake)
+            end
+            result
           end
 
-          def require_rake
-            require "rake" # Defer booting Rake until we know it's needed.
+          def rake_tasks
+            @rake_tasks ||= with_rake(&:tasks)
           end
       end
     end

data/lib/rails/commands/restart/restart_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class RestartCommand < Base # :nodoc:
+      desc "restart", "Restart app by touching tmp/restart.txt"
+      def perform
+        require "fileutils"
+        FileUtils.mkdir_p Rails::Command.application_root.join("tmp")
+        FileUtils.touch   Rails::Command.application_root.join("tmp/restart.txt")
+      end
+    end
+  end
+end

data/lib/rails/commands/routes/routes_command.rb

@@ -8,9 +8,21 @@ module Rails
       class_option :controller, aliases: "-c", desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController."
       class_option :grep, aliases: "-g", desc: "Grep routes by a specific pattern."
       class_option :expanded, type: :boolean, aliases: "-E", desc: "Print routes expanded vertically with parts explained."
+      class_option :unused, type: :boolean, aliases: "-u", desc: "Print unused routes."
 
+      no_commands do
+        def invoke_command(*)
+          if options.key?("unused")
+            Rails::Command.invoke "unused_routes", ARGV
+          else
+            super
+          end
+        end
+      end
+
+      desc "routes", "List all the defined routes"
       def perform(*)
-        require_application_and_environment!
+        boot_application!
         require "action_dispatch/routing/inspector"
 
         say inspector.format(formatter, routes_filter)