railties 6.0.3.3 → 6.1.1

data/lib/rails/application/default_middleware_stack.rb

@@ -13,10 +13,11 @@ module Rails
 
       def build_stack
         ActionDispatch::MiddlewareStack.new do |middleware|
-          middleware.use ::ActionDispatch::HostAuthorization, config.hosts, config.action_dispatch.hosts_response_app
+          middleware.use ::ActionDispatch::HostAuthorization, config.hosts, config.action_dispatch.hosts_response_app, **config.host_authorization
 
           if config.force_ssl
-            middleware.use ::ActionDispatch::SSL, **config.ssl_options
+            middleware.use ::ActionDispatch::SSL, **config.ssl_options,
+              ssl_default_redirect_status: config.action_dispatch.ssl_default_redirect_status
           end
 
           middleware.use ::Rack::Sendfile, config.action_dispatch.x_sendfile_header
@@ -43,7 +44,7 @@ module Rails
 
           middleware.use ::Rack::Runtime
           middleware.use ::Rack::MethodOverride unless config.api_only
-          middleware.use ::ActionDispatch::RequestId
+          middleware.use ::ActionDispatch::RequestId, header: config.action_dispatch.request_id_header
           middleware.use ::ActionDispatch::RemoteIp, config.action_dispatch.ip_spoofing_check, config.action_dispatch.trusted_proxies
 
           middleware.use ::Rails::Rack::Logger, config.log_tags
@@ -68,6 +69,7 @@ module Rails
 
           unless config.api_only
             middleware.use ::ActionDispatch::ContentSecurityPolicy::Middleware
+            middleware.use ::ActionDispatch::PermissionsPolicy::Middleware
           end
 
           middleware.use ::Rack::Head

data/lib/rails/application/finisher.rb

@@ -60,7 +60,18 @@ module Rails
 
           #{unload_message}
 
-          Please, check the "Autoloading and Reloading Constants" guide for solutions.
+          In order to autoload safely at boot time, please wrap your code in a reloader
+          callback this way:
+
+              Rails.application.reloader.to_prepare do
+                # Autoload classes and modules needed at boot time here.
+              end
+
+          That block runs when the application boots, and every time there is a reload.
+          For historical reasons, it may run twice, so it has to be idempotent.
+
+          Check the "Autoloading and Reloading Constants" guide to learn more about how
+          Rails autoloads and reloads.
         WARNING
       end
 
@@ -216,7 +227,9 @@ module Rails
           app.reloader.check = lambda { true }
         end
 
-        if config.reload_classes_only_on_change
+        if config.cache_classes
+          # No reloader
+        elsif config.reload_classes_only_on_change
           reloader = config.file_watcher.new(*watchable_args, &callback)
           reloaders << reloader
 

data/lib/rails/application/routes_reloader.rb

@@ -5,13 +5,14 @@ require "active_support/core_ext/module/delegation"
 module Rails
   class Application
     class RoutesReloader
-      attr_reader :route_sets, :paths
+      attr_reader :route_sets, :paths, :external_routes
       attr_accessor :eager_load
       delegate :execute_if_updated, :execute, :updated?, to: :updater
 
       def initialize
         @paths      = []
         @route_sets = []
+        @external_routes = []
         @eager_load = false
       end
 
@@ -26,7 +27,13 @@ module Rails
 
     private
       def updater
-        @updater ||= ActiveSupport::FileUpdateChecker.new(paths) { reload! }
+        @updater ||= begin
+          dirs = @external_routes.each_with_object({}) do |dir, hash|
+            hash[dir.to_s] = %w(rb)
+          end
+
+          ActiveSupport::FileUpdateChecker.new(paths, dirs) { reload! }
+        end
       end
 
       def clear!

data/lib/rails/backtrace_cleaner.rb

@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
 require "active_support/backtrace_cleaner"
+require "active_support/core_ext/string/access"
 
 module Rails
   class BacktraceCleaner < ActiveSupport::BacktraceCleaner
-    APP_DIRS_PATTERN = /^\/?(app|config|lib|test|\(\w*\))/
+    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/
     RENDER_TEMPLATE_PATTERN = /:in `.*_\w+_{2,3}\d+_\d+'/
-    EMPTY_STRING = ""
-    SLASH        = "/"
-    DOT_SLASH    = "./"
 
     def initialize
       super
       @root = "#{Rails.root}/"
-      add_filter { |line| line.sub(@root, EMPTY_STRING) }
-      add_filter { |line| line.sub(RENDER_TEMPLATE_PATTERN, EMPTY_STRING) }
-      add_filter { |line| line.sub(DOT_SLASH, SLASH) } # for tests
+      add_filter do |line|
+        line.start_with?(@root) ? line.from(@root.size) : line
+      end
+      add_filter do |line|
+        if RENDER_TEMPLATE_PATTERN.match?(line)
+          line.sub(RENDER_TEMPLATE_PATTERN, "")
+        else
+          line
+        end
+      end
       add_silencer { |line| !APP_DIRS_PATTERN.match?(line) }
     end
   end

data/lib/rails/code_statistics.rb

@@ -40,13 +40,13 @@ class CodeStatistics #:nodoc:
       Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
     end
 
-    def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|coffee|rake)$/)
+    def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|ts|coffee|rake)$/)
       stats = CodeStatisticsCalculator.new
 
       Dir.foreach(directory) do |file_name|
         path = "#{directory}/#{file_name}"
 
-        if File.directory?(path) && (/^\./ !~ file_name)
+        if File.directory?(path) && !file_name.start_with?(".")
           stats.add(calculate_directory_statistics(path, pattern))
         elsif file_name&.match?(pattern)
           stats.add_by_file_path(path)
@@ -75,7 +75,7 @@ class CodeStatistics #:nodoc:
     end
 
     def width_for(label)
-      [@statistics.values.sum { |s| s.send(label) }.to_s.size, HEADERS[label].length].max
+      [@statistics.values.sum { |s| s.public_send(label) }.to_s.size, HEADERS[label].length].max
     end
 
     def print_header

data/lib/rails/code_statistics_calculator.rb

@@ -58,20 +58,20 @@ class CodeStatisticsCalculator #:nodoc:
       @lines += 1
 
       if comment_started
-        if patterns[:end_block_comment] && line =~ patterns[:end_block_comment]
+        if patterns[:end_block_comment] && patterns[:end_block_comment].match?(line)
           comment_started = false
         end
         next
       else
-        if patterns[:begin_block_comment] && line =~ patterns[:begin_block_comment]
+        if patterns[:begin_block_comment] && patterns[:begin_block_comment].match?(line)
           comment_started = true
           next
         end
       end
 
-      @classes   += 1 if patterns[:class] && line =~ patterns[:class]
-      @methods   += 1 if patterns[:method] && line =~ patterns[:method]
-      if line !~ /^\s*$/ && (patterns[:line_comment].nil? || line !~ patterns[:line_comment])
+      @classes   += 1 if patterns[:class] && patterns[:class].match?(line)
+      @methods   += 1 if patterns[:method] && patterns[:method].match?(line)
+      if !line.match?(/^\s*$/) && (patterns[:line_comment].nil? || !line.match?(patterns[:line_comment]))
         @code_lines += 1
       end
     end
@@ -82,7 +82,7 @@ class CodeStatisticsCalculator #:nodoc:
       if file_path.end_with? "_test.rb"
         :minitest
       else
-        File.extname(file_path).sub(/\A\./, "").downcase.to_sym
+        File.extname(file_path).delete_prefix(".").downcase.to_sym
       end
     end
 end

data/lib/rails/command.rb

@@ -1,7 +1,6 @@
 # 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"
 
@@ -41,12 +40,19 @@ 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)
 
+        # isolate ARGV to ensure that commands depend only on the args they are given
+        args = args.dup # args might *be* ARGV so dup before clearing
+        old_argv = ARGV.dup
+        ARGV.clear
+
         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(old_argv)
       end
 
       # Rails finds namespaces similar to Thor, it only adds one rule:

data/lib/rails/command/base.rb

@@ -56,7 +56,7 @@ module Rails
         def inherited(base) #:nodoc:
           super
 
-          if base.name && base.name !~ /Base$/
+          if base.name && !base.name.end_with?("Base")
             Rails::Command.subclasses << base
           end
         end

data/lib/rails/command/behavior.rb

@@ -56,7 +56,7 @@ module Rails
           def lookup!
             $LOAD_PATH.each do |base|
               Dir[File.join(base, *file_lookup_paths)].each do |path|
-                path = path.sub("#{base}/", "")
+                path = path.delete_prefix("#{base}/")
                 require path
               rescue Exception
                 # No problem

data/lib/rails/command/environment_argument.rb

@@ -28,7 +28,7 @@ module Rails
           if available_environments.include? env
             env
           else
-            %w( production development test ).detect { |e| e =~ /^#{env}/ } || env
+            %w( production development test ).detect { |e| /^#{env}/.match?(e) } || env
           end
         end
 

data/lib/rails/commands/credentials/USAGE

@@ -14,7 +14,7 @@ that just contains the secret_key_base used by MessageVerifiers/MessageEncryptor
 signing and encrypting cookies.
 
 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 `rails credentials:edit`.
+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 lose this master key! Put it in a password manager your team can access.
@@ -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
@@ -45,7 +60,7 @@ The `credentials` command supports passing an `--environment` option to create a
 environment specific override. That override will take precedence over the
 global `config/credentials.yml.enc` file when running in that environment. So:
 
-   rails credentials:edit --environment development
+   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

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pathname"
 require "active_support"
 require "rails/command/helpers/editor"
 require "rails/command/environment_argument"
@@ -10,6 +11,9 @@ module Rails
       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
@@ -28,6 +32,7 @@ module Rails
 
         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
@@ -45,6 +50,23 @@ module Rails
         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 credentials
           Rails.application.encrypted(content_path, key_path: key_path)
@@ -71,21 +93,23 @@ module Rails
 
         def missing_credentials_message
           if credentials.key.nil?
-            "Missing '#{key_path}' to decrypt credentials. See `rails credentials:help`"
+            "Missing '#{key_path}' to decrypt credentials. See `bin/rails credentials:help`"
           else
-            "File '#{content_path}' does not exist. Use `rails credentials:edit` to change that."
+            "File '#{content_path}' does not exist. Use `bin/rails credentials:edit` to change that."
           end
         end
 
-
         def content_path
-          options[:environment] ? "config/credentials/#{options[:environment]}.yml.enc" : "config/credentials.yml.enc"
+          @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"

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/db/system/change/change_command.rb

@@ -10,8 +10,13 @@ module Rails
         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
+            Rails::Generators::Db::System::ChangeGenerator.start(@argv)
           end
         end
       end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "active_support/deprecation"
 require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
 require "rails/command/environment_argument"
 
 module Rails
@@ -16,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)
@@ -72,36 +73,43 @@ 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']}"
-          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 database the
-        # first time around to show a consistent error message to people
-        # relying on 2-level database configuration.
-        if @options["database"] && configurations[database].blank?
-          raise ActiveRecord::AdapterNotSpecified, "'#{database}' database is not configured. Available configuration: #{configurations.inspect}"
-        elsif configurations[environment].blank? && configurations[database].blank?
-          raise ActiveRecord::AdapterNotSpecified, "'#{environment}' database is not configured. Available configuration: #{configurations.inspect}"
-        else
-          configurations[database] || configurations[environment].presence
-        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)
+
+      unless @db_config
+        raise ActiveRecord::AdapterNotSpecified,
+          "'#{database}' database is not configured for '#{environment}'. Available configuration: #{configurations.inspect}"
       end
+
+      @db_config
     end
 
     def environment
@@ -131,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
 
@@ -155,9 +168,6 @@ 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."
 
@@ -167,13 +177,6 @@ module Rails
         # RAILS_ENV needs to be set before config/application is required.
         ENV["RAILS_ENV"] = options[:environment]
 
-        if options["connection"]
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `connection` option is deprecated and will be removed in Rails 6.1. Please use `database` option instead.
-          MSG
-          options["database"] = options["connection"]
-        end
-
         require_application_and_environment!
         Rails::DBConsole.start(options)
       end