railties 6.1.6 → 7.1.2

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"
 
@@ -10,13 +11,43 @@ module Rails
   module Command
     extend ActiveSupport::Autoload
 
-    autoload :Spellchecker
     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:
@@ -27,30 +58,28 @@ module Rails
         ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence || "development"
       end
 
-      # Receives a namespace, arguments and the behavior to invoke the command.
+      # 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 = "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
-          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:
@@ -58,14 +87,12 @@ module Rails
       # Command names must end with "_command.rb". This is required because Rails
       # looks in load paths and loads the command just before it's going to be used.
       #
-      #   find_by_namespace :webrat, :rails, :integration
+      #   find_by_namespace :webrat, :integration
       #
       # Will search for the following commands:
       #
-      #   "rails:webrat", "webrat:integration", "webrat"
+      #   "webrat", "webrat:integration", "rails:webrat", "rails:webrat:integration"
       #
-      # Notice that "rails:commands:webrat" could be loaded as well, what
-      # Rails looks for is the first and last parts of the namespace.
       def find_by_namespace(namespace, command_name = nil) # :nodoc:
         lookups = [ namespace ]
         lookups << "#{namespace}:#{command_name}" if command_name
@@ -77,29 +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
+
+      def printing_commands # :nodoc:
+        lookup!
+
+        (subclasses - hidden_commands).flat_map(&:printing_commands)
       end
 
       private
-        COMMANDS_IN_USAGE = %w(generate console server test test:system dbconsole new)
-        private_constant :COMMANDS_IN_USAGE
+        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,73 +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 `rails credentials:diff --enroll` to instruct Git to call `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.
 
-=== Editing Credentials
+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:
 
-This will open a temporary file in `$EDITOR` with the decrypted contents to edit
-the encrypted credentials.
+        <%= executable(:edit) %> --environment development
 
-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.
+    will create `config/credentials/development.yml.enc` with the corresponding
+    encryption key in `config/credentials/development.key` if the credentials file
+    doesn't exist.
 
-=== Environment Specific Credentials
+    In addition to that, the default credentials lookup paths can be overridden through
+    `config.credentials.content_path` and `config.credentials.key_path`.
 
-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

@@ -1,41 +1,53 @@
 # frozen_string_literal: true
 
 module Rails::Command::CredentialsCommand::Diffing # :nodoc:
+  GITATTRIBUTES_ENTRY = <<~END
+    config/credentials/*.yml.enc diff=rails_credentials
+    config/credentials.yml.enc diff=rails_credentials
+  END
+
   def enroll_project_in_credentials_diffing
-    if enrolled?
-      true
+    if enrolled_in_credentials_diffing?
+      say "Project is already enrolled in credentials file diffing."
     else
-      gitattributes.write(<<~end_of_template, mode: "a")
-        config/credentials/*.yml.enc diff=rails_credentials
-        config/credentials.yml.enc diff=rails_credentials
-      end_of_template
+      gitattributes.write(GITATTRIBUTES_ENTRY, mode: "a")
+
+      say "Enrolled project in credentials file diffing!"
+      say ""
+      say "Rails will configure the Git diff driver for credentials when running `#{executable(:edit)}`. See `#{executable(:help)}` for more information."
+    end
+  end
+
+  def disenroll_project_from_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      gitattributes.write(gitattributes.read.gsub(GITATTRIBUTES_ENTRY, ""))
+      gitattributes.delete if gitattributes.empty?
 
-      say "Project successfully enrolled!"
-      say "Rails ensures the rails_credentials diff driver is set when running `credentials:edit`. See `credentials:help` for more."
+      say "Disenrolled project from credentials file diffing!"
+    else
+      say "Project is not enrolled in credentials file diffing."
     end
   end
 
-  def ensure_rails_credentials_driver_is_set
-    set_driver if enrolled? && !driver_configured?
+  def ensure_diffing_driver_is_configured
+    configure_diffing_driver if enrolled_in_credentials_diffing? && !diffing_driver_configured?
   end
 
   private
-    def enrolled?
-      gitattributes.read.match?(/config\/credentials(\/\*)?\.yml\.enc diff=rails_credentials/)
-    rescue Errno::ENOENT
-      false
+    def enrolled_in_credentials_diffing?
+      gitattributes.file? && gitattributes.read.include?(GITATTRIBUTES_ENTRY)
     end
 
-    def driver_configured?
+    def diffing_driver_configured?
       system "git config --get diff.rails_credentials.textconv", out: File::NULL
     end
 
-    def set_driver
-      puts "running"
-      system "git config diff.rails_credentials.textconv 'bin/rails credentials:diff'"
+    def configure_diffing_driver
+      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