railties 7.0.8 → 7.2.0

data/lib/rails/command/base.rb

@@ -3,7 +3,8 @@
 require "thor"
 require "erb"
 
-require "active_support/core_ext/string/filters"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/string/inflections"
 
 require "rails/command/actions"
@@ -14,32 +15,16 @@ module Rails
       class Error < Thor::Error # :nodoc:
       end
 
-      class CorrectableError < Error # :nodoc:
-        attr_reader :key, :options
-
-        def initialize(message, key, options)
-          @key     = key
-          @options = options
-          super(message)
-        end
-
-        if defined?(DidYouMean::SpellChecker) && defined?(DidYouMean::Correctable)
-          include DidYouMean::Correctable
-
-          def corrections
-            @corrections ||= DidYouMean::SpellChecker.new(dictionary: options).correct(key)
-          end
-        end
-      end
-
       include Actions
 
+      class_attribute :bin, instance_accessor: false, default: "bin/rails"
+
       class << self
         def exit_on_failure? # :nodoc:
           false
         end
 
-        # Returns true when the app is a Rails engine.
+        # Returns true when the app is a \Rails engine.
         def engine?
           defined?(ENGINE_ROOT)
         end
@@ -50,7 +35,7 @@ module Rails
           if usage
             super
           else
-            @desc ||= ERB.new(File.read(usage_path), trim_mode: "-").result(binding) if usage_path
+            class_usage
           end
         end
 
@@ -81,23 +66,38 @@ module Rails
 
         def perform(command, args, config) # :nodoc:
           if Rails::Command::HELP_MAPPINGS.include?(args.first)
-            command, args = "help", []
+            command, args = "help", [command]
+            args.clear if instance_method(:help).arity.zero?
           end
 
           dispatch(command, args.dup, nil, config)
         end
 
         def printing_commands
-          namespaced_commands
+          commands.filter_map do |name, command|
+            [namespaced_name(name), command.description] unless command.hidden?
+          end
         end
 
-        def executable
-          "rails #{command_name}"
+        def executable(command_name = self.command_name)
+          "#{bin} #{namespaced_name(command_name)}"
         end
 
-        # Use Rails' default banner.
-        def banner(*)
-          "#{executable} #{arguments.map(&:usage).join(' ')} [options]".squish
+        def banner(command = nil, *)
+          if command
+            # Similar to Thor's banner, but show the namespace (minus the
+            # "rails:" prefix), and show the command's declared bin instead of
+            # the command runner.
+            command.formatted_usage(self).gsub(/^#{namespace}:(\w+)/) { executable($1) }
+          else
+            executable
+          end
+        end
+
+        # Override Thor's class-level help to also show the USAGE.
+        def help(shell, *) # :nodoc:
+          super
+          shell.say class_usage if class_usage
         end
 
         # Sets the base_name taking into account the current class namespace.
@@ -119,12 +119,16 @@ module Rails
           end
         end
 
+        def class_usage # :nodoc:
+          if usage_path
+            @class_usage ||= ERB.new(File.read(usage_path), trim_mode: "-").result(binding)
+          end
+        end
+
         # Path to lookup a USAGE description in a file.
         def usage_path
-          if default_command_root
-            path = File.join(default_command_root, "USAGE")
-            path if File.exist?(path)
-          end
+          @usage_path = resolve_path("USAGE") unless defined?(@usage_path)
+          @usage_path
         end
 
         # Default file root to place extra files a command might need, placed
@@ -133,8 +137,8 @@ module Rails
         # For a Rails::Command::TestCommand placed in <tt>rails/command/test_command.rb</tt>
         # would return <tt>rails/test</tt>.
         def default_command_root
-          path = File.expand_path(relative_command_path, __dir__)
-          path if File.exist?(path)
+          @default_command_root = resolve_path(".") unless defined?(@default_command_root)
+          @default_command_root
         end
 
         private
@@ -145,37 +149,35 @@ module Rails
             else
               # Prevent exception about command without usage.
               # Some commands define their documentation differently.
-              @usage ||= ""
+              @usage ||= meth
               @desc  ||= ""
 
               super
             end
           end
 
-          def command_root_namespace
-            (namespace.split(":") - %w(rails)).join(":")
-          end
-
-          def relative_command_path
-            File.join("../commands", *command_root_namespace.split(":"))
+          def namespaced_name(name)
+            *prefix, basename = namespace.delete_prefix("rails:").split(":")
+            prefix.concat([basename, name.to_s].uniq).join(":")
           end
 
-          def namespaced_commands
-            commands.keys.map do |key|
-              if command_root_namespace.match?(/(\A|:)#{key}\z/)
-                command_root_namespace
-              else
-                "#{command_root_namespace}:#{key}"
-              end
-            end
+          def resolve_path(path)
+            path = File.join("../commands", *namespace.delete_prefix("rails:").split(":"), path)
+            path = File.expand_path(path, __dir__)
+            path if File.exist?(path)
           end
       end
 
-      def help
-        if command_name = self.class.command_name
-          self.class.command_help(shell, command_name)
-        else
+      no_commands do
+        delegate :executable, to: :class
+        attr_reader :current_subcommand
+
+        def invoke_command(command, *) # :nodoc:
+          @current_subcommand ||= nil
+          original_subcommand, @current_subcommand = @current_subcommand, command.name
           super
+        ensure
+          @current_subcommand = original_subcommand
         end
       end
     end

data/lib/rails/command/environment_argument.rb

@@ -9,31 +9,47 @@ module Rails
       extend ActiveSupport::Concern
 
       included do
-        no_commands do
-          class_attribute :environment_desc, default: "Specifies the environment to run this #{self.command_name} under (test/development/production)."
+        class_option :environment, aliases: "-e", type: :string,
+          desc: "The environment to run `#{self.command_name}` in (e.g. test / development / production)."
+      end
+
+      def initialize(...)
+        super
+
+        @environment_specified = options[:environment].present?
+
+        if !@environment_specified
+          self.options = options.merge(environment: Rails::Command.environment)
+        elsif !available_environments.include?(options[:environment])
+          self.options = options.merge(environment: expand_environment_name(options[:environment]))
         end
-        class_option :environment, aliases: "-e", type: :string, desc: environment_desc
       end
 
       private
-        def extract_environment_option_from_argument(default_environment: Rails::Command.environment)
-          if options[:environment]
-            self.options = options.merge(environment: acceptable_environment(options[:environment]))
-          else
-            self.options = options.merge(environment: default_environment)
-          end
+        def require_application!
+          ENV["RAILS_ENV"] = environment
+          super
+        end
+
+        def environment
+          @environment ||= options[:environment]
+        end
+
+        def environment=(environment)
+          @environment = environment
         end
 
-        def acceptable_environment(env = nil)
-          if available_environments.include? env
-            env
-          else
-            %w( production development test ).detect { |e| /^#{env}/.match?(e) } || env
-          end
+        def environment_specified?
+          @environment_specified
         end
 
         def available_environments
-          Dir["config/environments/*.rb"].map { |fname| File.basename(fname, ".*") }
+          @available_environments ||=
+            Dir["config/environments/*.rb"].map { |filename| File.basename(filename, ".*") }
+        end
+
+        def expand_environment_name(name)
+          %w[production development test].find { |full_name| full_name.start_with?(name) } || name
         end
     end
   end

data/lib/rails/command/helpers/editor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "shellwords"
 require "active_support/encrypted_file"
 
 module Rails
@@ -7,27 +8,31 @@ module Rails
     module Helpers
       module Editor
         private
-          def ensure_editor_available(command:)
-            if ENV["EDITOR"].to_s.empty?
-              say "No $EDITOR to open file in. Assign one like this:"
+          def editor
+            ENV["VISUAL"].to_s.empty? ? ENV["EDITOR"] : ENV["VISUAL"]
+          end
+
+          def display_hint_if_system_editor_not_specified
+            if editor.to_s.empty?
+              say "No $VISUAL or $EDITOR to open file in. Assign one like this:"
               say ""
-              say %(EDITOR="mate --wait" #{command})
+              say %(VISUAL="mate --wait" #{executable(current_subcommand)})
               say ""
-              say "For editors that fork and exit immediately, it's important to pass a wait flag,"
-              say "otherwise the credentials will be saved immediately with no chance to edit."
+              say "For editors that fork and exit immediately, it's important to pass a wait flag;"
+              say "otherwise, the file will be saved immediately with no chance to edit."
 
-              false
-            else
               true
             end
           end
 
-          def catch_editing_exceptions
-            yield
+          def system_editor(file_path)
+            system(*Shellwords.split(editor), file_path.to_s)
+          end
+
+          def using_system_editor
+            display_hint_if_system_editor_not_specified || yield
           rescue Interrupt
             say "Aborted changing file: nothing saved."
-          rescue ActiveSupport::EncryptedFile::MissingKeyError => error
-            say error.message
           end
       end
     end

data/lib/rails/command.rb

@@ -3,6 +3,7 @@
 require "active_support"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/object/blank"
+require "rails/deprecator"
 
 require "thor"
 
@@ -13,9 +14,40 @@ module Rails
     autoload :Behavior
     autoload :Base
 
+    class CorrectableNameError < StandardError # :nodoc:
+      attr_reader :name
+
+      def initialize(message, name, alternatives)
+        @name = name
+        @alternatives = alternatives
+        super(message)
+      end
+
+      if !Exception.method_defined?(:detailed_message) # Ruby 3.2+
+        def detailed_message(...)
+          message
+        end
+      end
+
+      if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
+        include DidYouMean::Correctable
+
+        def corrections
+          @corrections ||= DidYouMean::SpellChecker.new(dictionary: @alternatives).correct(name)
+        end
+      end
+    end
+
+    class UnrecognizedCommandError < CorrectableNameError # :nodoc:
+      def initialize(name)
+        super("Unrecognized command #{name.inspect}", name, Command.printing_commands.map(&:first))
+      end
+    end
+
     include Behavior
 
-    HELP_MAPPINGS = %w(-h -? --help)
+    HELP_MAPPINGS = %w(-h -? --help).to_set
+    VERSION_MAPPINGS = %w(-v --version).to_set
 
     class << self
       def hidden_commands # :nodoc:
@@ -28,30 +60,26 @@ module Rails
 
       # Receives a namespace, arguments, and the behavior to invoke the command.
       def invoke(full_namespace, args = [], **config)
-        namespace = full_namespace = full_namespace.to_s
-
-        if char = namespace =~ /:(\w+)$/
-          command_name, namespace = $1, namespace.slice(0, char)
-        else
-          command_name = namespace
-        end
-
-        command_name, namespace = "help", "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
-        command_name, namespace, args = "application", "application", ["--help"] if rails_new_with_no_path?(args)
-        command_name, namespace = "version", "version" if %w( -v --version ).include?(command_name)
-
-        original_argv = ARGV.dup
-        ARGV.replace(args)
+        args = ["--help"] if rails_new_with_no_path?(args)
 
+        full_namespace = full_namespace.to_s
+        namespace, command_name = split_namespace(full_namespace)
         command = find_by_namespace(namespace, command_name)
-        if command && command.all_commands[command_name]
-          command.perform(command_name, args, config)
+
+        with_argv(args) do
+          if command && command.all_commands[command_name]
+            command.perform(command_name, args, config)
+          else
+            invoke_rake(full_namespace, args, config)
+          end
+        end
+      rescue UnrecognizedCommandError => error
+        if error.name == full_namespace && command && command_name == full_namespace
+          command.perform("help", [], config)
         else
-          args = ["--describe", full_namespace] if HELP_MAPPINGS.include?(args[0])
-          find_by_namespace("rake").perform(full_namespace, args, config)
+          puts error.detailed_message
         end
-      ensure
-        ARGV.replace(original_argv)
+        exit(1)
       end
 
       # Rails finds namespaces similar to Thor, it only adds one rule:
@@ -76,33 +104,56 @@ module Rails
         namespaces[(lookups & namespaces.keys).first]
       end
 
-      # Returns the root of the Rails engine or app running the command.
+      # Returns the root of the \Rails engine or app running the command.
       def root
         if defined?(ENGINE_ROOT)
           Pathname.new(ENGINE_ROOT)
-        elsif defined?(APP_PATH)
-          Pathname.new(File.expand_path("../..", APP_PATH))
+        else
+          application_root
         end
       end
 
-      def print_commands # :nodoc:
-        commands.each { |command| puts("  #{command}") }
+      def application_root # :nodoc:
+        Pathname.new(File.expand_path("../..", APP_PATH)) if defined?(APP_PATH)
       end
 
-      private
-        COMMANDS_IN_USAGE = %w(generate console server test test:system dbconsole new)
-        private_constant :COMMANDS_IN_USAGE
+      def printing_commands # :nodoc:
+        lookup!
+
+        (subclasses - hidden_commands).flat_map(&:printing_commands)
+      end
 
+      private
         def rails_new_with_no_path?(args)
           args == ["new"]
         end
 
-        def commands
-          lookup!
+        def split_namespace(namespace)
+          case namespace
+          when /^(.+):(\w+)$/
+            [$1, $2]
+          when ""
+            ["help", "help"]
+          when HELP_MAPPINGS, "help"
+            ["help", "help_extended"]
+          when VERSION_MAPPINGS
+            ["version", "version"]
+          else
+            [namespace, namespace]
+          end
+        end
 
-          visible_commands = (subclasses - hidden_commands).flat_map(&:printing_commands)
+        def with_argv(argv)
+          original_argv = ARGV.dup
+          ARGV.replace(argv)
+          yield
+        ensure
+          ARGV.replace(original_argv)
+        end
 
-          (visible_commands - COMMANDS_IN_USAGE).sort
+        def invoke_rake(task, args, config)
+          args = ["--describe", task] if HELP_MAPPINGS.include?(args[0])
+          find_by_namespace("rake").perform(task, args, config)
         end
 
         def command_type # :doc:

data/lib/rails/commands/about/about_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    class AboutCommand < Base # :nodoc:
+      desc "about", "List versions of all Rails frameworks and the environment"
+      def perform
+        boot_application!
+
+        say Rails::Info
+      end
+    end
+  end
+end

data/lib/rails/commands/app/update_command.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/app/app_generator"
+
+module Rails
+  module Command
+    module App
+      class UpdateCommand < Base # :nodoc:
+        include Thor::Actions
+        add_runtime_options!
+
+        desc "update", "Update configs and some other initially generated files (or use just update:configs or update:bin)"
+        def perform
+          configs
+          bin
+          public_directory
+          active_storage
+          display_upgrade_guide_info
+        end
+
+        desc "configs", "Update config files in the application config/ directory", hide: true
+        def configs
+          require_application!
+          app_generator.create_boot_file
+          app_generator.update_config_files
+        end
+
+        desc "bin", "Add or update executables in the application bin/ directory", hide: true
+        def bin
+          require_application!
+          app_generator.update_bin_files
+        end
+
+        desc "public_directory", "Add or update files in the application public/ directory", hide: true
+        def public_directory
+          require_application!
+          app_generator.create_public_files
+        end
+
+        desc "active_storage", "Run the active_storage:update command", hide: true
+        def active_storage
+          require_application!
+          app_generator.update_active_storage
+        end
+
+        private
+          def display_upgrade_guide_info
+            say "\nAfter this, check Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html for more details about upgrading your app."
+          end
+
+          def app_generator
+            @app_generator ||= begin
+              gen = Rails::Generators::AppGenerator.new(["rails"], generator_options, destination_root: Rails.root)
+              gen.send(:valid_const?) unless File.exist?(Rails.root.join("config", "application.rb"))
+              gen
+            end
+          end
+
+          def generator_options
+            {
+              api:                 !!Rails.application.config.api_only,
+              update:              true,
+              name:                Rails.application.class.name.chomp("::Application").underscore,
+              skip_active_job:     !defined?(ActiveJob::Railtie),
+              skip_active_record:  !defined?(ActiveRecord::Railtie),
+              skip_active_storage: !defined?(ActiveStorage::Engine),
+              skip_action_mailer:  !defined?(ActionMailer::Railtie),
+              skip_action_mailbox: !defined?(ActionMailbox::Engine),
+              skip_action_text:    !defined?(ActionText::Engine),
+              skip_action_cable:   !defined?(ActionCable::Engine),
+              skip_test:           !defined?(Rails::TestUnitRailtie),
+              skip_system_test:    Rails.application.config.generators.system_tests.nil?,
+              asset_pipeline:      asset_pipeline,
+              skip_asset_pipeline: asset_pipeline.nil?,
+              skip_bootsnap:       !defined?(Bootsnap),
+            }.merge(options)
+          end
+
+          def asset_pipeline
+            case
+            when defined?(Sprockets::Railtie)
+              "sprockets"
+            when defined?(Propshaft::Railtie)
+              "propshaft"
+            else
+              nil
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails/commands/application/application_command.rb

@@ -18,6 +18,8 @@ module Rails
     class ApplicationCommand < Base # :nodoc:
       hide_command!
 
+      self.bin = "rails"
+
       def help
         perform # Punt help output to the generator.
       end

data/lib/rails/commands/boot/boot_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class BootCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "boot", "Boot the application and exit"
+      def perform(*) = boot_application!
+    end
+  end
+end

data/lib/rails/commands/console/console_command.rb

@@ -1,20 +1,9 @@
 # frozen_string_literal: true
 
-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
@@ -34,19 +23,18 @@ module Rails
 
       app.load_console
 
-      @console = app.config.console || IRB
-
-      if @console == IRB
-        IRB::WorkSpace.prepend(BacktraceCleaner)
-
-        if Rails.env.production?
-          ENV["IRB_USE_AUTOCOMPLETE"] ||= "false"
-        end
+      @console = app.config.console || begin
+        require "rails/commands/console/irb_console"
+        IRBConsole.new(app)
       end
     end
 
     def sandbox?
-      options[:sandbox]
+      return options[:sandbox] if !options[:sandbox].nil?
+
+      return false if Rails.env.local?
+
+      app.config.sandbox_by_default
     end
 
     def environment
@@ -68,9 +56,6 @@ module Rails
         puts "Loading #{Rails.env} environment (Rails #{Rails.version})"
       end
 
-      if defined?(console::ExtendCommandBundle)
-        console::ExtendCommandBundle.include(Rails::ConsoleMethods)
-      end
       console.start
     end
   end
@@ -79,7 +64,7 @@ module Rails
     class ConsoleCommand < Base # :nodoc:
       include EnvironmentArgument
 
-      class_option :sandbox, aliases: "-s", type: :boolean, default: false,
+      class_option :sandbox, aliases: "-s", type: :boolean, default: nil,
         desc: "Rollback database modifications on exit."
 
       def initialize(args = [], local_options = {}, config = {})
@@ -96,13 +81,9 @@ module Rails
         super(args, local_options, config)
       end
 
+      desc "console", "Start the Rails console"
       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::Console.start(Rails.application, options)
       end
     end