railties 7.0.4 → 7.1.3.4

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)
+        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/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/console/console_command.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "irb"
-require "irb/completion"
-
 require "rails/command/environment_argument"
 
 module Rails
@@ -34,15 +31,26 @@ module Rails
 
       app.load_console
 
-      @console = app.config.console || IRB
+      @console = app.config.console || begin
+        require "irb"
+        require "irb/completion"
 
-      if @console == IRB
         IRB::WorkSpace.prepend(BacktraceCleaner)
+
+        if !Rails.env.local?
+          ENV["IRB_USE_AUTOCOMPLETE"] ||= "false"
+        end
+
+        IRB
       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
@@ -75,7 +83,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 = {})
@@ -92,13 +100,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

data/lib/rails/commands/credentials/USAGE

@@ -1,75 +1,73 @@
-=== Storing Encrypted Credentials in Source Control
+Description:
+    The Rails `credentials` commands provide access to encrypted credentials,
+    so you can safely store access tokens, database passwords, and the like
+    safely inside the app without relying on a mess of ENVs.
 
-The Rails `credentials` commands provide access to encrypted credentials,
-so you can safely store access tokens, database passwords, and the like
-safely inside the app without relying on a mess of ENVs.
+    This also allows for atomic deploys: no need to coordinate key changes
+    to get everything working as the keys are shipped with the code.
 
-This also allows for atomic deploys: no need to coordinate key changes
-to get everything working as the keys are shipped with the code.
+Setup:
+    Applications after Rails 5.2 automatically have a basic credentials file generated
+    that just contains the secret_key_base used by MessageVerifiers/MessageEncryptors, like the ones
+    signing and encrypting cookies.
 
-=== Setup
+    For applications created prior to Rails 5.2, we'll automatically generate a new
+    credentials file in `config/credentials.yml.enc` the first time you run `<%= executable(:edit) %>`.
+    If you didn't have a master key saved in `config/master.key`, that'll be created too.
 
-Applications after Rails 5.2 automatically have a basic credentials file generated
-that just contains the secret_key_base used by MessageVerifiers/MessageEncryptors, like the ones
-signing and encrypting cookies.
+    Don't lose this master key! Put it in a password manager your team can access.
+    Should you lose it no one, including you, will be able to access any encrypted
+    credentials.
 
-For applications created prior to Rails 5.2, we'll automatically generate a new
-credentials file in `config/credentials.yml.enc` the first time you run `bin/rails credentials:edit`.
-If you didn't have a master key saved in `config/master.key`, that'll be created too.
+    Don't commit the key! Add `config/master.key` to your source control's
+    ignore file. If you use Git, Rails handles this for you.
 
-Don't lose this master key! Put it in a password manager your team can access.
-Should you lose it no one, including you, will be able to access any encrypted
-credentials.
+    Rails also looks for the master key in `ENV["RAILS_MASTER_KEY"]`, in case that
+    is easier to manage. You could set `RAILS_MASTER_KEY` in a deployment
+    configuration, or you could prepend it to your server's start command like so:
 
-Don't commit the key! Add `config/master.key` to your source control's
-ignore file. If you use Git, Rails handles this for you.
+        RAILS_MASTER_KEY="very-secret-and-secure" bin/rails server
 
-Rails also looks for the master key in `ENV["RAILS_MASTER_KEY"]`, if that's easier to manage.
+    If `ENV["RAILS_MASTER_KEY"]` is present, it takes precedence over
+    `config/master.key`.
 
-You could prepend that to your server's start command like this:
+Set up Git to Diff Credentials:
+    Rails provides `<%= executable(:diff) %> --enroll` to instruct Git to call
+    `<%= executable(:diff) %>` when `git diff` is run on a credentials file.
 
-   RAILS_MASTER_KEY="very-secret-and-secure" server.start
+    Running the command enrolls the project such that all credentials files use the
+    "rails_credentials" diff driver in .gitattributes.
 
-=== Set up Git to Diff Credentials
+    Additionally since Git requires the driver itself to be set up in a config file
+    that isn't tracked Rails automatically ensures it's configured when running
+    `<%= executable(:edit) %>`.
 
-Rails provides `bin/rails credentials:diff --enroll` to instruct Git to call
-`bin/rails credentials:diff` when `git diff` is run on a credentials file.
+    Otherwise each co-worker would have to run enable manually, including on each new
+    repo clone.
 
-Running the command enrolls the project such that all credentials files use the
-"rails_credentials" diff driver in .gitattributes.
+    To disenroll from this feature, run `<%= executable(:diff) %> --disenroll`.
 
-Additionally since Git requires the driver itself to be set up in a config file
-that isn't tracked Rails automatically ensures it's configured when running
-`credentials:edit`.
+Editing Credentials:
+    This will open a temporary file in `$VISUAL` or `$EDITOR` with the decrypted
+    contents to edit the encrypted credentials.
 
-Otherwise each co-worker would have to run enable manually, including on each new
-repo clone.
+    When the temporary file is next saved the contents are encrypted and written to
+    `config/credentials.yml.enc` while the file itself is destroyed to prevent credentials
+    from leaking.
 
-To disenroll from this feature, run `bin/rails credentials:diff --disenroll`.
+Environment Specific Credentials:
+    The `credentials` command supports passing an `--environment` option to create an
+    environment specific override. That override will take precedence over the
+    global `config/credentials.yml.enc` file when running in that environment. So:
 
-=== Editing Credentials
+        <%= executable(:edit) %> --environment development
 
-This will open a temporary file in `$EDITOR` with the decrypted contents to edit
-the encrypted credentials.
+    will create `config/credentials/development.yml.enc` with the corresponding
+    encryption key in `config/credentials/development.key` if the credentials file
+    doesn't exist.
 
-When the temporary file is next saved the contents are encrypted and written to
-`config/credentials.yml.enc` while the file itself is destroyed to prevent credentials
-from leaking.
+    In addition to that, the default credentials lookup paths can be overridden through
+    `config.credentials.content_path` and `config.credentials.key_path`.
 
-=== Environment Specific Credentials
-
-The `credentials` command supports passing an `--environment` option to create an
-environment specific override. That override will take precedence over the
-global `config/credentials.yml.enc` file when running in that environment. So:
-
-   bin/rails credentials:edit --environment development
-
-will create `config/credentials/development.yml.enc` with the corresponding
-encryption key in `config/credentials/development.key` if the credentials file
-doesn't exist.
-
-The encryption key can also be put in `ENV["RAILS_MASTER_KEY"]`, which takes
-precedence over the file encryption key.
-
-In addition to that, the default credentials lookup paths can be overridden through
-`config.credentials.content_path` and `config.credentials.key_path`.
+    Just as with `config/master.key`, `ENV["RAILS_MASTER_KEY"]` takes precedence
+    over any environment specific or specially configured key files.

data/lib/rails/commands/credentials/credentials_command/diffing.rb

@@ -13,7 +13,8 @@ module Rails::Command::CredentialsCommand::Diffing # :nodoc:
       gitattributes.write(GITATTRIBUTES_ENTRY, mode: "a")
 
       say "Enrolled project in credentials file diffing!"
-      say "Rails ensures the rails_credentials diff driver is set when running `credentials:edit`. See `credentials:help` for more."
+      say ""
+      say "Rails will configure the Git diff driver for credentials when running `#{executable(:edit)}`. See `#{executable(:help)}` for more information."
     end
   end
 
@@ -42,10 +43,11 @@ module Rails::Command::CredentialsCommand::Diffing # :nodoc:
     end
 
     def configure_diffing_driver
-      system "git config diff.rails_credentials.textconv 'bin/rails credentials:diff'"
+      system "git config diff.rails_credentials.textconv '#{executable(:diff)}'"
+      say "Configured Git diff driver for credentials."
     end
 
     def gitattributes
-      Rails.root.join(".gitattributes")
+      @gitattributes ||= (Rails::Command.root || Pathname.pwd).join(".gitattributes")
     end
 end