railties 5.2.7.1 → 6.1.4.6

data/lib/rails/command/spellchecker.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Rails
+  module Command
+    module Spellchecker # :nodoc:
+      class << self
+        def suggest(word, from:)
+          if defined?(DidYouMean::SpellChecker)
+            DidYouMean::SpellChecker.new(dictionary: from.map(&:to_s)).correct(word).first
+          else
+            from.sort_by { |w| levenshtein_distance(word, w) }.first
+          end
+        end
+
+        private
+          # This code is based directly on the Text gem implementation.
+          # Copyright (c) 2006-2013 Paul Battley, Michael Neumann, Tim Fletcher.
+          #
+          # Returns a value representing the "cost" of transforming str1 into str2.
+          def levenshtein_distance(str1, str2) # :doc:
+            s = str1
+            t = str2
+            n = s.length
+            m = t.length
+
+            return m if 0 == n
+            return n if 0 == m
+
+            d = (0..m).to_a
+            x = nil
+
+            # avoid duplicating an enumerable object in the loop
+            str2_codepoint_enumerable = str2.each_codepoint
+
+            str1.each_codepoint.with_index do |char1, i|
+              e = i + 1
+
+              str2_codepoint_enumerable.with_index do |char2, j|
+                cost = (char1 == char2) ? 0 : 1
+                x = [
+                  d[j + 1] + 1, # insertion
+                  e + 1,        # deletion
+                  d[j] + cost   # substitution
+                ].min
+                d[j] = e
+                e = x
+              end
+
+              d[m] = x
+            end
+
+            x
+          end
+      end
+    end
+  end
+end

data/lib/rails/command.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 require "active_support"
-require "active_support/dependencies/autoload"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/object/blank"
-require "active_support/core_ext/hash/transform_values"
 
 require "thor"
 
@@ -12,6 +10,7 @@ module Rails
   module Command
     extend ActiveSupport::Autoload
 
+    autoload :Spellchecker
     autoload :Behavior
     autoload :Base
 
@@ -41,12 +40,17 @@ module Rails
         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)
+
         command = find_by_namespace(namespace, command_name)
         if command && command.all_commands[command_name]
           command.perform(command_name, args, config)
         else
           find_by_namespace("rake").perform(full_namespace, args, config)
         end
+      ensure
+        ARGV.replace(original_argv)
       end
 
       # Rails finds namespaces similar to Thor, it only adds one rule:
@@ -83,20 +87,21 @@ module Rails
       end
 
       def print_commands # :nodoc:
-        sorted_groups.each { |b, n| print_list(b, n) }
+        commands.each { |command| puts("  #{command}") }
       end
 
-      def sorted_groups # :nodoc:
-        lookup!
+      private
+        COMMANDS_IN_USAGE = %w(generate console server test test:system dbconsole new)
+        private_constant :COMMANDS_IN_USAGE
 
-        groups = (subclasses - hidden_commands).group_by { |c| c.namespace.split(":").first }
-        groups.transform_values! { |commands| commands.flat_map(&:printing_commands).sort }
+        def commands
+          lookup!
 
-        rails = groups.delete("rails")
-        [[ "rails", rails ]] + groups.sort.to_a
-      end
+          visible_commands = (subclasses - hidden_commands).flat_map(&:printing_commands)
+
+          (visible_commands - COMMANDS_IN_USAGE).sort
+        end
 
-      private
         def command_type # :doc:
           @command_type ||= "command"
         end

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

@@ -26,6 +26,12 @@ module Rails
       @options = options
 
       app.sandbox = sandbox?
+
+      if sandbox? && app.config.disable_sandbox
+        puts "Error: Unable to start console in sandbox mode as sandbox mode is disabled (config.disable_sandbox is true)."
+        exit 1
+      end
+
       app.load_console
 
       @console = app.config.console || IRB

data/lib/rails/commands/credentials/USAGE

@@ -30,6 +30,21 @@ You could prepend that to your server's start command like this:
 
    RAILS_MASTER_KEY="very-secret-and-secure" server.start
 
+=== Set up Git to Diff Credentials
+
+Rails provides `rails credentials:diff --enroll` to instruct Git to call `rails credentials:diff`
+when `git diff` is run on a credentials file.
+
+Running the command enrolls the project such that all credentials files use the
+"rails_credentials" diff driver in .gitattributes.
+
+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`.
+
+Otherwise each co-worker would have to run enable manually, including on each new
+repo clone.
+
 === Editing Credentials
 
 This will open a temporary file in `$EDITOR` with the decrypted contents to edit
@@ -38,3 +53,21 @@ the encrypted credentials.
 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.
+
+=== 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`.

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rails::Command::CredentialsCommand::Diffing # :nodoc:
+  def enroll_project_in_credentials_diffing
+    if enrolled?
+      true
+    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
+
+      say "Project successfully enrolled!"
+      say "Rails ensures the rails_credentials diff driver is set when running `credentials:edit`. See `credentials:help` for more."
+    end
+  end
+
+  def ensure_rails_credentials_driver_is_set
+    set_driver if enrolled? && !driver_configured?
+  end
+
+  private
+    def enrolled?
+      gitattributes.read.match?(/config\/credentials(\/\*)?\.yml\.enc diff=rails_credentials/)
+    rescue Errno::ENOENT
+      false
+    end
+
+    def 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'"
+    end
+
+    def gitattributes
+      Rails.root.join(".gitattributes")
+    end
+end

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

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
+require "pathname"
 require "active_support"
 require "rails/command/helpers/editor"
+require "rails/command/environment_argument"
 
 module Rails
   module Command
     class CredentialsCommand < Rails::Command::Base # :nodoc:
       include Helpers::Editor
+      include EnvironmentArgument
+
+      require_relative "credentials_command/diffing"
+      include Diffing
+
+      self.environment_desc = "Uses credentials from config/credentials/:environment.yml.enc encrypted by config/credentials/:environment.key key"
 
       no_commands do
         def help
@@ -17,47 +25,104 @@ module Rails
       end
 
       def edit
+        extract_environment_option_from_argument(default_environment: nil)
         require_application!
 
         ensure_editor_available(command: "bin/rails credentials:edit") || (return)
-        ensure_master_key_has_been_added if Rails.application.credentials.key.nil?
+
+        ensure_encryption_key_has_been_added if credentials.key.nil?
         ensure_credentials_have_been_added
+        ensure_rails_credentials_driver_is_set
 
         catch_editing_exceptions do
           change_credentials_in_system_editor
         end
 
-        say "New credentials encrypted and saved."
+        say "File encrypted and saved."
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
       end
 
       def show
+        extract_environment_option_from_argument(default_environment: nil)
         require_application!
 
-        say Rails.application.credentials.read.presence || missing_credentials_message
+        say credentials.read.presence || missing_credentials_message
+      end
+
+      option :enroll, type: :boolean, default: false,
+        desc: "Enrolls project in credential file diffing with `git diff`"
+
+      def diff(content_path = nil)
+        if @content_path = content_path
+          extract_environment_option_from_argument(default_environment: extract_environment_from_path(content_path))
+          require_application!
+
+          say credentials.read.presence || credentials.content_path.read
+        else
+          require_application!
+          enroll_project_in_credentials_diffing if options[:enroll]
+        end
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say credentials.content_path.read
       end
 
       private
-        def ensure_master_key_has_been_added
-          master_key_generator.add_master_key_file
-          master_key_generator.ignore_master_key_file
+        def credentials
+          Rails.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          encryption_key_file_generator.add_key_file(key_path)
+          encryption_key_file_generator.ignore_key_file(key_path)
         end
 
         def ensure_credentials_have_been_added
-          credentials_generator.add_credentials_file_silently
+          if options[:environment]
+            encrypted_file_generator.add_encrypted_file_silently(content_path, key_path)
+          else
+            credentials_generator.add_credentials_file_silently
+          end
         end
 
         def change_credentials_in_system_editor
-          Rails.application.credentials.change do |tmp_path|
+          credentials.change do |tmp_path|
             system("#{ENV["EDITOR"]} #{tmp_path}")
           end
         end
 
+        def missing_credentials_message
+          if credentials.key.nil?
+            "Missing '#{key_path}' to decrypt credentials. See `bin/rails credentials:help`"
+          else
+            "File '#{content_path}' does not exist. Use `bin/rails credentials:edit` to change that."
+          end
+        end
 
-        def master_key_generator
+        def content_path
+          @content_path ||= options[:environment] ? "config/credentials/#{options[:environment]}.yml.enc" : "config/credentials.yml.enc"
+        end
+
+        def key_path
+          options[:environment] ? "config/credentials/#{options[:environment]}.key" : "config/master.key"
+        end
+
+        def extract_environment_from_path(path)
+          available_environments.find { |env| path.include? env } if path.end_with?(".yml.enc")
+        end
+
+        def encryption_key_file_generator
           require "rails/generators"
-          require "rails/generators/rails/master_key/master_key_generator"
+          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
 
-          Rails::Generators::MasterKeyGenerator.new
+          Rails::Generators::EncryptionKeyFileGenerator.new
+        end
+
+        def encrypted_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encrypted_file/encrypted_file_generator"
+
+          Rails::Generators::EncryptedFileGenerator.new
         end
 
         def credentials_generator
@@ -66,14 +131,6 @@ module Rails
 
           Rails::Generators::CredentialsGenerator.new
         end
-
-        def missing_credentials_message
-          if Rails.application.credentials.key.nil?
-            "Missing master key to decrypt credentials. See bin/rails credentials:help"
-          else
-            "No credentials have been added yet. Use bin/rails credentials:edit to change that."
-          end
-        end
     end
   end
 end

data/lib/rails/commands/db/system/change/change_command.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/db/system/change/change_generator"
+
+module Rails
+  module Command
+    module Db
+      module System
+        class ChangeCommand < Base # :nodoc:
+          class_option :to, desc: "The database system to switch to."
+
+          def initialize(positional_args, option_args, *)
+            @argv = positional_args + option_args
+            super
+          end
+
+          def perform
+            Rails::Generators::Db::System::ChangeGenerator.start(@argv)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
 require "rails/command/environment_argument"
 
 module Rails
@@ -14,55 +16,56 @@ module Rails
 
     def start
       ENV["RAILS_ENV"] ||= @options[:environment] || environment
+      config = db_config.configuration_hash
 
-      case config["adapter"]
+      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"
+          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?
+        if config[:password] && @options[:include_password]
+          args << "--password=#{config[:password]}"
+        elsif config[:password] && !config[:password].to_s.empty?
           args << "-p"
         end
 
-        args << config["database"]
+        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"]
-        find_cmd_and_exec("psql", config["database"])
+        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", db_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)
+        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 << "@#{config['database']}" if config["database"]
+        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)
@@ -70,44 +73,51 @@ module Rails
       when "sqlserver"
         args = []
 
-        args += ["-D", "#{config['database']}"] if config["database"]
-        args += ["-U", "#{config['username']}"] if config["username"]
-        args += ["-P", "#{config['password']}"] if config["password"]
+        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 = "#{config['host']}".dup
-          host_arg << ":#{config['port']}" if config["port"]
+        if config[:host]
+          host_arg = +"tcp:#{config[:host]}"
+          host_arg << ",#{config[:port]}" if config[:port]
           args += ["-S", host_arg]
         end
 
-        find_cmd_and_exec("sqsh", *args)
+        find_cmd_and_exec("sqlcmd", *args)
 
       else
-        abort "Unknown command-line client for #{config['database']}."
+        abort "Unknown command-line client for #{db_config.database}."
       end
     end
 
     def config
-      @config ||= begin
-        # We need to check whether the user passed the connection the
-        # first time around to show a consistent error message to people
-        # relying on 2-level database configuration.
-        if @options["connection"] && configurations[connection].blank?
-          raise ActiveRecord::AdapterNotSpecified, "'#{connection}' connection is not configured. Available configuration: #{configurations.inspect}"
-        elsif configurations[environment].blank? && configurations[connection].blank?
-          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
-        else
-          configurations[environment].presence || configurations[connection]
-        end
+      db_config.configuration_hash
+    end
+    deprecate config: "please use db_config.configuration_hash"
+
+    def db_config
+      return @db_config if defined?(@db_config)
+
+      # We need to check whether the user passed the database the
+      # first time around to show a consistent error message to people
+      # relying on 2-level database configuration.
+
+      @db_config = configurations.configs_for(env_name: environment, name: database, include_replicas: true)
+
+      unless @db_config
+        raise ActiveRecord::AdapterNotSpecified,
+          "'#{database}' database is not configured for '#{environment}'. Available configuration: #{configurations.inspect}"
       end
+
+      @db_config
     end
 
     def environment
       Rails.respond_to?(:env) ? Rails.env : Rails::Command.environment
     end
 
-    def connection
-      @options.fetch(:connection, "primary")
+    def database
+      @options.fetch(:database, "primary")
     end
 
     private
@@ -129,7 +139,12 @@ module Rails
         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)
+            begin
+              stat = File.stat(full_path_command)
+            rescue SystemCallError
+            else
+              stat.file? && stat.executable?
+            end
           end
         end
 
@@ -153,8 +168,8 @@ module Rails
 
       class_option :header, type: :boolean
 
-      class_option :connection, aliases: "-c", type: :string,
-        desc: "Specifies the connection to use."
+      class_option :database, aliases: "--db", type: :string,
+        desc: "Specifies the database to use."
 
       def perform
         extract_environment_option_from_argument

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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
+
+      def cache
+        Rails::DevCaching.enable_by_file
+      end
+    end
+  end
+end

data/lib/rails/commands/encrypted/USAGE

@@ -6,7 +6,7 @@ See the `Rails.application.encrypted` documentation for using them in your app.
 === Encryption Keys
 
 By default, Rails looks for the encryption key in `config/master.key` or
-`ENV["RAILS_MASTER_KEY"]`, but that lookup can be overriden with `--key`:
+`ENV["RAILS_MASTER_KEY"]`, but that lookup can be overridden with `--key`:
 
    rails encrypted:edit config/encrypted_file.yml.enc --key config/encrypted_file.key
 

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

@@ -21,7 +21,7 @@ module Rails
       end
 
       def edit(file_path)
-        require_application_and_environment!
+        require_application!
         encrypted = Rails.application.encrypted(file_path, key_path: options[:key])
 
         ensure_editor_available(command: "bin/rails encrypted:edit") || (return)
@@ -38,7 +38,7 @@ module Rails
       end
 
       def show(file_path)
-        require_application_and_environment!
+        require_application!
         encrypted = Rails.application.encrypted(file_path, key_path: options[:key])
 
         say encrypted.read.presence || missing_encrypted_message(key: encrypted.key, key_path: options[:key], file_path: file_path)
@@ -77,9 +77,9 @@ module Rails
 
         def missing_encrypted_message(key:, key_path:, file_path:)
           if key.nil?
-            "Missing '#{key_path}' to decrypt data. See bin/rails encrypted:help"
+            "Missing '#{key_path}' to decrypt data. See `bin/rails encrypted:help`"
           else
-            "File '#{file_path}' does not exist. Use bin/rails encrypted:edit #{file_path} to change that."
+            "File '#{file_path}' does not exist. Use `bin/rails encrypted:edit #{file_path}` to change that."
           end
         end
     end

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

@@ -21,7 +21,7 @@ module Rails
         require_application_and_environment!
         load_generators
 
-        ARGV.shift
+        ARGV.replace(args) # set up ARGV for third-party libraries
 
         Rails::Generators.invoke generator, args, behavior: :invoke, destination_root: Rails::Command.root
       end

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

@@ -6,7 +6,7 @@ module Rails
       hide_command!
 
       def help(*)
-        puts self.class.desc
+        say self.class.desc
 
         Rails::Command.print_commands
       end