railties 5.2.4.1 → 6.0.1

data/lib/rails/application/bootstrap.rb

@@ -34,20 +34,12 @@ INFO
       # Initialize the logger early in the stack in case we need to log some deprecation.
       initializer :initialize_logger, group: :all do
         Rails.logger ||= config.logger || begin
-          path = config.paths["log"].first
-          unless File.exist? File.dirname path
-            FileUtils.mkdir_p File.dirname path
-          end
-
-          f = File.open path, "a"
-          f.binmode
-          f.sync = config.autoflush_log # if true make sure every write flushes
-
-          logger = ActiveSupport::Logger.new f
+          logger = ActiveSupport::Logger.new(config.default_log_file)
           logger.formatter = config.log_formatter
           logger = ActiveSupport::TaggedLogging.new(logger)
           logger
         rescue StandardError
+          path = config.paths["log"].first
           logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDERR))
           logger.level = ActiveSupport::Logger::WARN
           logger.warn(

data/lib/rails/application/configuration.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "ipaddr"
 require "active_support/core_ext/kernel/reporting"
 require "active_support/file_update_checker"
 require "rails/engine/configuration"
@@ -11,15 +12,16 @@ module Rails
       attr_accessor :allow_concurrency, :asset_host, :autoflush_log,
                     :cache_classes, :cache_store, :consider_all_requests_local, :console,
                     :eager_load, :exceptions_app, :file_watcher, :filter_parameters,
-                    :force_ssl, :helpers_paths, :logger, :log_formatter, :log_tags,
-                    :railties_order, :relative_url_root, :secret_key_base, :secret_token,
+                    :force_ssl, :helpers_paths, :hosts, :logger, :log_formatter, :log_tags,
+                    :railties_order, :relative_url_root, :secret_key_base,
                     :ssl_options, :public_file_server,
                     :session_options, :time_zone, :reload_classes_only_on_change,
                     :beginning_of_week, :filter_redirect, :x, :enable_dependency_loading,
                     :read_encrypted_secrets, :log_level, :content_security_policy_report_only,
-                    :content_security_policy_nonce_generator, :require_master_key
+                    :content_security_policy_nonce_generator, :content_security_policy_nonce_directives,
+                    :require_master_key, :credentials, :disable_sandbox, :add_autoload_paths_to_load_path
 
-      attr_reader :encoding, :api_only, :loaded_config_version
+      attr_reader :encoding, :api_only, :loaded_config_version, :autoloader
 
       def initialize(*)
         super
@@ -29,6 +31,7 @@ module Rails
         @filter_parameters                       = []
         @filter_redirect                         = []
         @helpers_paths                           = []
+        @hosts                                   = Array(([IPAddr.new("0.0.0.0/0"), IPAddr.new("::/0"), ".localhost"] if Rails.env.development?))
         @public_file_server                      = ActiveSupport::OrderedOptions.new
         @public_file_server.enabled              = true
         @public_file_server.index_name           = "index"
@@ -48,7 +51,6 @@ module Rails
         @autoflush_log                           = true
         @log_formatter                           = ActiveSupport::Logger::SimpleFormatter.new
         @eager_load                              = nil
-        @secret_token                            = nil
         @secret_key_base                         = nil
         @api_only                                = false
         @debug_exception_response_format         = nil
@@ -58,8 +60,15 @@ module Rails
         @content_security_policy                 = nil
         @content_security_policy_report_only     = false
         @content_security_policy_nonce_generator = nil
+        @content_security_policy_nonce_directives = nil
         @require_master_key                      = false
         @loaded_config_version                   = nil
+        @credentials                             = ActiveSupport::OrderedOptions.new
+        @credentials.content_path                = default_credentials_content_path
+        @credentials.key_path                    = default_credentials_key_path
+        @autoloader                              = :classic
+        @disable_sandbox                         = false
+        @add_autoload_paths_to_load_path         = true
       end
 
       def load_defaults(target_version)
@@ -92,10 +101,6 @@ module Rails
 
           if respond_to?(:active_record)
             active_record.cache_versioning = true
-            # Remove the temporary load hook from SQLite3Adapter when this is removed
-            ActiveSupport.on_load(:active_record_sqlite3adapter) do
-              ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer = true
-            end
           end
 
           if respond_to?(:action_dispatch)
@@ -114,6 +119,38 @@ module Rails
           if respond_to?(:action_view)
             action_view.form_with_generates_ids = true
           end
+        when "6.0"
+          load_defaults "5.2"
+
+          self.autoloader = :zeitwerk if RUBY_ENGINE == "ruby"
+
+          if respond_to?(:action_view)
+            action_view.default_enforce_utf8 = false
+          end
+
+          if respond_to?(:action_dispatch)
+            action_dispatch.use_cookies_with_metadata = true
+            action_dispatch.return_only_media_type_on_content_type = false
+          end
+
+          if respond_to?(:action_mailer)
+            action_mailer.delivery_job = "ActionMailer::MailDeliveryJob"
+          end
+
+          if respond_to?(:active_job)
+            active_job.return_false_on_aborted_enqueue = true
+          end
+
+          if respond_to?(:active_storage)
+            active_storage.queues.analysis = :active_storage_analysis
+            active_storage.queues.purge    = :active_storage_purge
+
+            active_storage.replace_on_assign_to_many = true
+          end
+
+          if respond_to?(:active_record)
+            active_record.collection_cache_versioning = true
+          end
         else
           raise "Unknown version #{target_version.to_s.inspect}"
         end
@@ -140,9 +177,7 @@ module Rails
         @debug_exception_response_format || :default
       end
 
-      def debug_exception_response_format=(value)
-        @debug_exception_response_format = value
-      end
+      attr_writer :debug_exception_response_format
 
       def paths
         @paths ||= begin
@@ -160,6 +195,26 @@ module Rails
         end
       end
 
+      # Load the database YAML without evaluating ERB. This allows us to
+      # create the rake tasks for multiple databases without filling in the
+      # configuration values or loading the environment. Do not use this
+      # method.
+      #
+      # This uses a DummyERB custom compiler so YAML can ignore the ERB
+      # tags and load the database.yml for the rake tasks.
+      def load_database_yaml # :nodoc:
+        if path = paths["config/database"].existent.first
+          require "rails/application/dummy_erb_compiler"
+
+          yaml = Pathname.new(path)
+          erb = DummyERB.new(yaml.read)
+
+          YAML.load(erb.result) || {}
+        else
+          {}
+        end
+      end
+
       # Loads and returns the entire raw configuration of database from
       # values stored in <tt>config/database.yml</tt>.
       def database_configuration
@@ -235,7 +290,7 @@ module Rails
       end
 
       def annotations
-        SourceAnnotationExtractor::Annotation
+        Rails::SourceAnnotationExtractor::Annotation
       end
 
       def content_security_policy(&block)
@@ -246,6 +301,30 @@ module Rails
         end
       end
 
+      def autoloader=(autoloader)
+        case autoloader
+        when :classic
+          @autoloader = autoloader
+        when :zeitwerk
+          require "zeitwerk"
+          @autoloader = autoloader
+        else
+          raise ArgumentError, "config.autoloader may be :classic or :zeitwerk, got #{autoloader.inspect} instead"
+        end
+      end
+
+      def default_log_file
+        path = paths["log"].first
+        unless File.exist? File.dirname path
+          FileUtils.mkdir_p File.dirname path
+        end
+
+        f = File.open path, "a"
+        f.binmode
+        f.sync = autoflush_log # if true make sure every write flushes
+        f
+      end
+
       class Custom #:nodoc:
         def initialize
           @configurations = Hash.new
@@ -265,6 +344,27 @@ module Rails
           true
         end
       end
+
+      private
+        def default_credentials_content_path
+          if credentials_available_for_current_env?
+            root.join("config", "credentials", "#{Rails.env}.yml.enc")
+          else
+            root.join("config", "credentials.yml.enc")
+          end
+        end
+
+        def default_credentials_key_path
+          if credentials_available_for_current_env?
+            root.join("config", "credentials", "#{Rails.env}.key")
+          else
+            root.join("config", "master.key")
+          end
+        end
+
+        def credentials_available_for_current_env?
+          File.exist?(root.join("config", "credentials", "#{Rails.env}.yml.enc"))
+        end
     end
   end
 end

data/lib/rails/application/default_middleware_stack.rb

@@ -13,6 +13,8 @@ module Rails
 
       def build_stack
         ActionDispatch::MiddlewareStack.new do |middleware|
+          middleware.use ::ActionDispatch::HostAuthorization, config.hosts, config.action_dispatch.hosts_response_app
+
           if config.force_ssl
             middleware.use ::ActionDispatch::SSL, config.ssl_options
           end
@@ -47,6 +49,7 @@ module Rails
           middleware.use ::Rails::Rack::Logger, config.log_tags
           middleware.use ::ActionDispatch::ShowExceptions, show_exceptions_app
           middleware.use ::ActionDispatch::DebugExceptions, app, config.debug_exception_response_format
+          middleware.use ::ActionDispatch::ActionableExceptions
 
           unless config.cache_classes
             middleware.use ::ActionDispatch::Reloader, app.reloader

data/lib/rails/application/dummy_erb_compiler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# These classes are used to strip out the ERB configuration
+# values so we can evaluate the database.yml without evaluating
+# the ERB values.
+class DummyERB < ERB # :nodoc:
+  def make_compiler(trim_mode)
+    DummyCompiler.new trim_mode
+  end
+end
+
+class DummyCompiler < ERB::Compiler # :nodoc:
+  def compile_content(stag, out)
+    if stag == "<%="
+      out.push "_erbout << ''"
+    end
+  end
+end

data/lib/rails/application/finisher.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/array/conversions"
+
 module Rails
   class Application
     module Finisher
@@ -21,6 +24,53 @@ module Rails
         end
       end
 
+      # This will become an error if/when we remove classic mode. The plan is
+      # autoloaders won't be configured up to this point in the finisher, so
+      # constants just won't be found, raising regular NameError exceptions.
+      initializer :warn_if_autoloaded, before: :let_zeitwerk_take_over do
+        next if config.cache_classes
+        next if ActiveSupport::Dependencies.autoloaded_constants.empty?
+
+        autoloaded    = ActiveSupport::Dependencies.autoloaded_constants
+        constants     = "constant".pluralize(autoloaded.size)
+        enum          = autoloaded.to_sentence
+        have          = autoloaded.size == 1 ? "has" : "have"
+        these         = autoloaded.size == 1 ? "This" : "These"
+        example       = autoloaded.first
+        example_klass = example.constantize.class
+
+        if config.autoloader == :zeitwerk
+          ActiveSupport::DescendantsTracker.clear
+          ActiveSupport::Dependencies.clear
+
+          unload_message = "#{these} autoloaded #{constants} #{have} been unloaded."
+        else
+          unload_message = "`config.autoloader` is set to `#{config.autoloader}`. #{these} autoloaded #{constants} would have been unloaded if `config.autoloader` had been set to `:zeitwerk`."
+        end
+
+        ActiveSupport::Deprecation.warn(<<~WARNING)
+          Initialization autoloaded the #{constants} #{enum}.
+
+          Being able to do this is deprecated. Autoloading during initialization is going
+          to be an error condition in future versions of Rails.
+
+          Reloading does not reboot the application, and therefore code executed during
+          initialization does not run again. So, if you reload #{example}, for example,
+          the expected changes won't be reflected in that stale #{example_klass} object.
+
+          #{unload_message}
+
+          Please, check the "Autoloading and Reloading Constants" guide for solutions.
+        WARNING
+      end
+
+      initializer :let_zeitwerk_take_over do
+        if config.autoloader == :zeitwerk
+          require "active_support/dependencies/zeitwerk_integration"
+          ActiveSupport::Dependencies::ZeitwerkIntegration.take_over(enable_reloading: !config.cache_classes)
+        end
+      end
+
       initializer :add_builtin_route do |app|
         if Rails.env.development?
           app.routes.prepend do
@@ -66,6 +116,10 @@ module Rails
       initializer :eager_load! do
         if config.eager_load
           ActiveSupport.run_load_hooks(:before_eager_load, self)
+          # Checks defined?(Zeitwerk) instead of zeitwerk_enabled? because we
+          # want to eager load any dependency managed by Zeitwerk regardless of
+          # the autoloading mode of the application.
+          Zeitwerk::Loader.eager_load_all if defined?(Zeitwerk)
           config.eager_load_namespaces.each(&:eager_load!)
         end
       end

data/lib/rails/autoloaders.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_support/dependencies/zeitwerk_integration"
+
+module Rails
+  module Autoloaders # :nodoc:
+    class << self
+      include Enumerable
+
+      def main
+        if zeitwerk_enabled?
+          @main ||= Zeitwerk::Loader.new.tap do |loader|
+            loader.tag = "rails.main"
+            loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+          end
+        end
+      end
+
+      def once
+        if zeitwerk_enabled?
+          @once ||= Zeitwerk::Loader.new.tap do |loader|
+            loader.tag = "rails.once"
+            loader.inflector = ActiveSupport::Dependencies::ZeitwerkIntegration::Inflector
+          end
+        end
+      end
+
+      def each
+        if zeitwerk_enabled?
+          yield main
+          yield once
+        end
+      end
+
+      def logger=(logger)
+        each { |loader| loader.logger = logger }
+      end
+
+      def log!
+        each(&:log!)
+      end
+
+      def zeitwerk_enabled?
+        Rails.configuration.autoloader == :zeitwerk
+      end
+    end
+  end
+end

data/lib/rails/backtrace_cleaner.rb

@@ -5,30 +5,18 @@ require "active_support/backtrace_cleaner"
 module Rails
   class BacktraceCleaner < ActiveSupport::BacktraceCleaner
     APP_DIRS_PATTERN = /^\/?(app|config|lib|test|\(\w*\))/
-    RENDER_TEMPLATE_PATTERN = /:in `_render_template_\w*'/
-    EMPTY_STRING = "".freeze
-    SLASH        = "/".freeze
-    DOT_SLASH    = "./".freeze
+    RENDER_TEMPLATE_PATTERN = /:in `.*_\w+_{2,3}\d+_\d+'/
+    EMPTY_STRING = ""
+    SLASH        = "/"
+    DOT_SLASH    = "./"
 
     def initialize
       super
-      @root = "#{Rails.root}/".freeze
+      @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_gem_filters
       add_silencer { |line| !APP_DIRS_PATTERN.match?(line) }
     end
-
-    private
-      def add_gem_filters
-        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
-        return if gems_paths.empty?
-
-        gems_regexp = %r{(#{gems_paths.join('|')})/gems/([^/]+)-([\w.]+)/(.*)}
-        gems_result = '\2 (\3) \4'.freeze
-        add_filter { |line| line.sub(gems_regexp, gems_result) }
-      end
   end
 end

data/lib/rails/code_statistics.rb

@@ -46,7 +46,7 @@ class CodeStatistics #:nodoc:
 
         if File.directory?(path) && (/^\./ !~ file_name)
           stats.add(calculate_directory_statistics(path, pattern))
-        elsif file_name =~ pattern
+        elsif file_name&.match?(pattern)
           stats.add_by_file_path(path)
         end
       end
@@ -95,8 +95,8 @@ class CodeStatistics #:nodoc:
     end
 
     def print_line(name, statistics)
-      m_over_c   = (statistics.methods / statistics.classes) rescue m_over_c = 0
-      loc_over_m = (statistics.code_lines / statistics.methods) - 2 rescue loc_over_m = 0
+      m_over_c   = (statistics.methods / statistics.classes) rescue 0
+      loc_over_m = (statistics.code_lines / statistics.methods) - 2 rescue 0
 
       print "| #{name.ljust(20)} "
       HEADERS.each_key do |k|