railties 7.2.3 → 8.0.0.beta1

data/lib/rails/application/finisher.rb

@@ -143,6 +143,7 @@ module Rails
           app.routes.prepend do
             get "/rails/info/properties" => "rails/info#properties", internal: true
             get "/rails/info/routes"     => "rails/info#routes",     internal: true
+            get "/rails/info/notes"      => "rails/info#notes",      internal: true
             get "/rails/info"            => "rails/info#index",      internal: true
           end
 
@@ -159,7 +160,6 @@ module Rails
       initializer :set_routes_reloader_hook do |app|
         reloader = routes_reloader
         reloader.eager_load = app.config.eager_load
-        reloader.execute
         reloaders << reloader
 
         app.reloader.to_run do
@@ -177,7 +177,7 @@ module Rails
           ActiveSupport.run_load_hooks(:after_routes_loaded, self)
         end
 
-        ActiveSupport.run_load_hooks(:after_routes_loaded, self)
+        reloader.execute_unless_loaded if !app.routes.is_a?(Engine::LazyRouteSet) || app.config.eager_load
       end
 
       # Set clearing dependencies after the finisher hook to ensure paths

data/lib/rails/application/routes_reloader.rb

@@ -7,7 +7,7 @@ module Rails
     class RoutesReloader
       include ActiveSupport::Callbacks
 
-      attr_reader :route_sets, :paths, :external_routes
+      attr_reader :route_sets, :paths, :external_routes, :loaded
       attr_accessor :eager_load
       attr_writer :run_after_load_paths # :nodoc:
       delegate :execute_if_updated, :execute, :updated?, to: :updater
@@ -17,9 +17,11 @@ module Rails
         @route_sets = []
         @external_routes = []
         @eager_load = false
+        @loaded = false
       end
 
       def reload!
+        @loaded = true
         clear!
         load_paths
         finalize!
@@ -28,6 +30,14 @@ module Rails
         revert
       end
 
+      def execute_unless_loaded
+        unless @loaded
+          execute
+          ActiveSupport.run_load_hooks(:after_routes_loaded, Rails.application)
+          true
+        end
+      end
+
     private
       def updater
         @updater ||= begin

data/lib/rails/application.rb

@@ -9,6 +9,7 @@ require "active_support/deprecation"
 require "active_support/encrypted_configuration"
 require "active_support/hash_with_indifferent_access"
 require "active_support/configuration_file"
+require "active_support/parameter_filter"
 require "rails/engine"
 require "rails/autoloaders"
 
@@ -160,6 +161,10 @@ module Rails
       routes_reloader.reload!
     end
 
+    def reload_routes_unless_loaded # :nodoc:
+      initialized? && routes_reloader.execute_unless_loaded
+    end
+
     # Returns a key generator (ActiveSupport::CachingKeyGenerator) for a
     # specified +secret_key_base+. The return value is memoized, so additional
     # calls with the same +secret_key_base+ will return the same key generator
@@ -454,21 +459,18 @@ module Rails
     # is used to create all ActiveSupport::MessageVerifier and ActiveSupport::MessageEncryptor instances,
     # including the ones that sign and encrypt cookies.
     #
-    # We look for it first in <tt>ENV["SECRET_KEY_BASE"]</tt>, then in
-    # +credentials.secret_key_base+. For most applications, the correct place
-    # to store it is in the encrypted credentials file.
+    # In development and test, this is randomly generated and stored in a
+    # temporary file in <tt>tmp/local_secret.txt</tt>.
     #
-    # In development and test, if the secret_key_base is still empty, it is
-    # randomly generated and stored in a temporary file in
-    # <tt>tmp/local_secret.txt</tt>.
-    #
-    # Generating a random secret_key_base and storing it in
-    # <tt>tmp/local_secret.txt</tt> can also be triggered by setting
-    # <tt>ENV["SECRET_KEY_BASE_DUMMY"]</tt>. This is useful when precompiling
-    # assets for production as part of a build step that otherwise does not
-    # need access to the production secrets.
+    # You can also set <tt>ENV["SECRET_KEY_BASE_DUMMY"]</tt> to trigger the use of a randomly generated
+    # secret_key_base that's stored in a temporary file. This is useful when precompiling assets for
+    # production as part of a build step that otherwise does not need access to the production secrets.
     #
     # Dockerfile example: <tt>RUN SECRET_KEY_BASE_DUMMY=1 bundle exec rails assets:precompile</tt>.
+    #
+    # In all other environments, we look for it first in <tt>ENV["SECRET_KEY_BASE"]</tt>,
+    # then +credentials.secret_key_base+. For most applications, the correct place to store it is in the
+    # encrypted credentials file.
     def secret_key_base
       config.secret_key_base
     end

data/lib/rails/backtrace_cleaner.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/string/access"
 
 module Rails
   class BacktraceCleaner < ActiveSupport::BacktraceCleaner # :nodoc:
-    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w+(?:-\w+)*\))/
+    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/
     RENDER_TEMPLATE_PATTERN = /:in [`'].*_\w+_{2,3}\d+_\d+'/
 
     def initialize

data/lib/rails/code_statistics.rb

@@ -3,115 +3,157 @@
 require "rails/code_statistics_calculator"
 require "active_support/core_ext/enumerable"
 
-class CodeStatistics # :nodoc:
-  TEST_TYPES = ["Controller tests",
-                "Helper tests",
-                "Model tests",
-                "Mailer tests",
-                "Mailbox tests",
-                "Channel tests",
-                "Job tests",
-                "Integration tests",
-                "System tests"]
-
-  HEADERS = { lines: " Lines", code_lines: "   LOC", classes: "Classes", methods: "Methods" }
-
-  def initialize(*pairs)
-    @pairs      = pairs
-    @statistics = calculate_statistics
-    @total      = calculate_total if pairs.length > 1
-  end
+module Rails
+  class CodeStatistics
+    DIRECTORIES = [
+      %w(Controllers        app/controllers),
+      %w(Helpers            app/helpers),
+      %w(Jobs               app/jobs),
+      %w(Models             app/models),
+      %w(Mailers            app/mailers),
+      %w(Mailboxes          app/mailboxes),
+      %w(Channels           app/channels),
+      %w(Views              app/views),
+      %w(JavaScripts        app/assets/javascripts),
+      %w(Stylesheets        app/assets/stylesheets),
+      %w(JavaScript         app/javascript),
+      %w(Libraries          lib/),
+      %w(APIs               app/apis),
+      %w(Controller\ tests  test/controllers),
+      %w(Helper\ tests      test/helpers),
+      %w(Job\ tests         test/jobs),
+      %w(Model\ tests       test/models),
+      %w(Mailer\ tests      test/mailers),
+      %w(Mailbox\ tests     test/mailboxes),
+      %w(Channel\ tests     test/channels),
+      %w(Integration\ tests test/integration),
+      %w(System\ tests      test/system),
+    ]
+
+    TEST_TYPES = ["Controller tests",
+                  "Helper tests",
+                  "Model tests",
+                  "Mailer tests",
+                  "Mailbox tests",
+                  "Channel tests",
+                  "Job tests",
+                  "Integration tests",
+                  "System tests"]
+
+    HEADERS = { lines: " Lines", code_lines: "   LOC", classes: "Classes", methods: "Methods" }
+
+    class_attribute :directories, default: DIRECTORIES
+    class_attribute :test_types, default: TEST_TYPES
+
+    # Add directories to the output of the `bin/rails stats` command.
+    #
+    #   Rails::CodeStatistics.register_directory("My Directory", "path/to/dir")
+    #
+    # For directories that contain test code, set the `test_directory` argument to true.
+    #
+    #   Rails::CodeStatistics.register_directory("Model specs", "spec/models", test_directory: true)
+    def self.register_directory(label, path, test_directory: false)
+      self.directories << [label, path]
+      self.test_types << label if test_directory
+    end
 
-  def to_s
-    print_header
-    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
-    print_splitter
+    def initialize(*pairs)
+      @pairs      = pairs
+      @statistics = calculate_statistics
+      @total      = calculate_total if pairs.length > 1
+    end
 
-    if @total
-      print_line("Total", @total)
+    def to_s
+      print_header
+      @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
       print_splitter
-    end
 
-    print_code_test_stats
-  end
+      if @total
+        print_line("Total", @total)
+        print_splitter
+      end
 
-  private
-    def calculate_statistics
-      Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
+      print_code_test_stats
     end
 
-    def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|ts|css|scss|coffee|rake|erb)$/)
-      stats = CodeStatisticsCalculator.new
+    private
+      def calculate_statistics
+        Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
+      end
+
+      def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|ts|css|scss|coffee|rake|erb)$/)
+        stats = Rails::CodeStatisticsCalculator.new
 
-      Dir.foreach(directory) do |file_name|
-        path = "#{directory}/#{file_name}"
+        Dir.foreach(directory) do |file_name|
+          path = "#{directory}/#{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)
+          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)
+          end
         end
-      end
 
-      stats
-    end
+        stats
+      end
 
-    def calculate_total
-      @statistics.each_with_object(CodeStatisticsCalculator.new) do |pair, total|
-        total.add(pair.last)
+      def calculate_total
+        @statistics.each_with_object(Rails::CodeStatisticsCalculator.new) do |pair, total|
+          total.add(pair.last)
+        end
       end
-    end
 
-    def calculate_code
-      code_loc = 0
-      @statistics.each { |k, v| code_loc += v.code_lines unless TEST_TYPES.include? k }
-      code_loc
-    end
+      def calculate_code
+        code_loc = 0
+        @statistics.each { |k, v| code_loc += v.code_lines unless test_types.include? k }
+        code_loc
+      end
 
-    def calculate_tests
-      test_loc = 0
-      @statistics.each { |k, v| test_loc += v.code_lines if TEST_TYPES.include? k }
-      test_loc
-    end
+      def calculate_tests
+        test_loc = 0
+        @statistics.each { |k, v| test_loc += v.code_lines if test_types.include? k }
+        test_loc
+      end
 
-    def width_for(label)
-      [@statistics.values.sum { |s| s.public_send(label) }.to_s.size, HEADERS[label].length].max
-    end
+      def width_for(label)
+        [@statistics.values.sum { |s| s.public_send(label) }.to_s.size, HEADERS[label].length].max
+      end
 
-    def print_header
-      print_splitter
-      print "| Name                "
-      HEADERS.each do |k, v|
-        print " | #{v.rjust(width_for(k))}"
+      def print_header
+        print_splitter
+        print "| Name                "
+        HEADERS.each do |k, v|
+          print " | #{v.rjust(width_for(k))}"
+        end
+        puts " | M/C | LOC/M |"
+        print_splitter
       end
-      puts " | M/C | LOC/M |"
-      print_splitter
-    end
 
-    def print_splitter
-      print "+----------------------"
-      HEADERS.each_key do |k|
-        print "+#{'-' * (width_for(k) + 2)}"
+      def print_splitter
+        print "+----------------------"
+        HEADERS.each_key do |k|
+          print "+#{'-' * (width_for(k) + 2)}"
+        end
+        puts "+-----+-------+"
       end
-      puts "+-----+-------+"
-    end
 
-    def print_line(name, statistics)
-      m_over_c   = (statistics.methods / statistics.classes) rescue 0
-      loc_over_m = (statistics.code_lines / statistics.methods) - 2 rescue 0
+      def print_line(name, statistics)
+        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|
-        print "| #{statistics.send(k).to_s.rjust(width_for(k))} "
+        print "| #{name.ljust(20)} "
+        HEADERS.each_key do |k|
+          print "| #{statistics.send(k).to_s.rjust(width_for(k))} "
+        end
+        puts "| #{m_over_c.to_s.rjust(3)} | #{loc_over_m.to_s.rjust(5)} |"
       end
-      puts "| #{m_over_c.to_s.rjust(3)} | #{loc_over_m.to_s.rjust(5)} |"
-    end
 
-    def print_code_test_stats
-      code  = calculate_code
-      tests = calculate_tests
+      def print_code_test_stats
+        code  = calculate_code
+        tests = calculate_tests
 
-      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f / code)}"
-      puts ""
-    end
+        puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f / code)}"
+        puts ""
+      end
+  end
 end

data/lib/rails/code_statistics_calculator.rb

@@ -1,97 +1,99 @@
 # frozen_string_literal: true
 
-class CodeStatisticsCalculator # :nodoc:
-  attr_reader :lines, :code_lines, :classes, :methods
+module Rails
+  class CodeStatisticsCalculator # :nodoc:
+    attr_reader :lines, :code_lines, :classes, :methods
 
-  PATTERNS = {
-    rb: {
-      line_comment: /^\s*#/,
-      begin_block_comment: /^=begin/,
-      end_block_comment: /^=end/,
-      class: /^\s*class\s+[_A-Z]/,
-      method: /^\s*def\s+[_a-z]/,
-    },
-    erb: {
-      line_comment: %r{((^\s*<%#.*%>)|(<!--.*-->))},
-    },
-    css: {
-      line_comment: %r{^\s*/\*.*\*/},
-    },
-    scss: {
-      line_comment: %r{((^\s*/\*.*\*/)|(^\s*//))},
-    },
-    js: {
-      line_comment: %r{^\s*//},
-      begin_block_comment: %r{^\s*/\*},
-      end_block_comment: %r{\*/},
-      method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
-    },
-    coffee: {
-      line_comment: /^\s*#/,
-      begin_block_comment: /^\s*###/,
-      end_block_comment: /^\s*###/,
-      class: /^\s*class\s+[_A-Z]/,
-      method: /[-=]>/,
+    PATTERNS = {
+      rb: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^=begin/,
+        end_block_comment: /^=end/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /^\s*def\s+[_a-z]/,
+      },
+      erb: {
+        line_comment: %r{((^\s*<%#.*%>)|(<!--.*-->))},
+      },
+      css: {
+        line_comment: %r{^\s*/\*.*\*/},
+      },
+      scss: {
+        line_comment: %r{((^\s*/\*.*\*/)|(^\s*//))},
+      },
+      js: {
+        line_comment: %r{^\s*//},
+        begin_block_comment: %r{^\s*/\*},
+        end_block_comment: %r{\*/},
+        method: /function(\s+[_a-zA-Z][\da-zA-Z]*)?\s*\(/,
+      },
+      coffee: {
+        line_comment: /^\s*#/,
+        begin_block_comment: /^\s*###/,
+        end_block_comment: /^\s*###/,
+        class: /^\s*class\s+[_A-Z]/,
+        method: /[-=]>/,
+      }
     }
-  }
 
-  PATTERNS[:minitest] = PATTERNS[:rb].merge method: /^\s*(def|test)\s+['"_a-z]/
-  PATTERNS[:rake] = PATTERNS[:rb]
+    PATTERNS[:minitest] = PATTERNS[:rb].merge method: /^\s*(def|test)\s+['"_a-z]/
+    PATTERNS[:rake] = PATTERNS[:rb]
 
-  def initialize(lines = 0, code_lines = 0, classes = 0, methods = 0)
-    @lines = lines
-    @code_lines = code_lines
-    @classes = classes
-    @methods = methods
-  end
+    def initialize(lines = 0, code_lines = 0, classes = 0, methods = 0)
+      @lines = lines
+      @code_lines = code_lines
+      @classes = classes
+      @methods = methods
+    end
 
-  def add(code_statistics_calculator)
-    @lines += code_statistics_calculator.lines
-    @code_lines += code_statistics_calculator.code_lines
-    @classes += code_statistics_calculator.classes
-    @methods += code_statistics_calculator.methods
-  end
+    def add(code_statistics_calculator)
+      @lines += code_statistics_calculator.lines
+      @code_lines += code_statistics_calculator.code_lines
+      @classes += code_statistics_calculator.classes
+      @methods += code_statistics_calculator.methods
+    end
 
-  def add_by_file_path(file_path)
-    File.open(file_path) do |f|
-      add_by_io(f, file_type(file_path))
+    def add_by_file_path(file_path)
+      File.open(file_path) do |f|
+        add_by_io(f, file_type(file_path))
+      end
     end
-  end
 
-  def add_by_io(io, file_type)
-    patterns = PATTERNS[file_type] || {}
+    def add_by_io(io, file_type)
+      patterns = PATTERNS[file_type] || {}
 
-    comment_started = false
+      comment_started = false
 
-    while line = io.gets
-      @lines += 1
+      while line = io.gets
+        @lines += 1
 
-      if comment_started
-        if patterns[:end_block_comment] && patterns[:end_block_comment].match?(line)
-          comment_started = false
-        end
-        next
-      else
-        if patterns[:begin_block_comment] && patterns[:begin_block_comment].match?(line)
-          comment_started = true
+        if comment_started
+          if patterns[:end_block_comment] && patterns[:end_block_comment].match?(line)
+            comment_started = false
+          end
           next
+        else
+          if patterns[:begin_block_comment] && patterns[:begin_block_comment].match?(line)
+            comment_started = true
+            next
+          end
         end
-      end
 
-      @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
+        @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
     end
-  end
 
-  private
-    def file_type(file_path)
-      if file_path.end_with? "_test.rb"
-        :minitest
-      else
-        File.extname(file_path).delete_prefix(".").downcase.to_sym
+    private
+      def file_type(file_path)
+        if file_path.end_with? "_test.rb"
+          :minitest
+        else
+          File.extname(file_path).delete_prefix(".").downcase.to_sym
+        end
       end
-    end
+  end
 end

data/lib/rails/command/helpers/editor.rb

@@ -16,7 +16,7 @@ module Rails
             if editor.to_s.empty?
               say "No $VISUAL or $EDITOR to open file in. Assign one like this:"
               say ""
-              say %(VISUAL="mate --wait" #{executable(current_subcommand)})
+              say %(VISUAL="code --wait" #{executable(current_subcommand)})
               say ""
               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."

data/lib/rails/commands/app/update_command.rb

@@ -73,21 +73,13 @@ module Rails
               skip_rubocop:        skip_gem?("rubocop"),
               skip_test:           !defined?(Rails::TestUnitRailtie),
               skip_system_test:    Rails.application.config.generators.system_tests.nil?,
-              asset_pipeline:      asset_pipeline,
               skip_asset_pipeline: asset_pipeline.nil?,
               skip_bootsnap:       !defined?(Bootsnap),
             }.merge(options)
           end
 
           def asset_pipeline
-            case
-            when defined?(Sprockets::Railtie)
-              "sprockets"
-            when defined?(Propshaft::Railtie)
-              "propshaft"
-            else
-              nil
-            end
+            "propshaft" if defined?(Propshaft::Railtie)
           end
 
           def skip_gem?(gem_name)

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

@@ -51,10 +51,13 @@ module Rails
       end
     end
 
-    class ReloadHelper < RailsHelperBase
+    class Reloader < IRB::Command::Base
+      include ConsoleMethods
+
+      category "Rails console"
       description "Reloads the Rails application."
 
-      def execute
+      def execute(*)
         puts "Reloading..."
         Rails.application.reloader.reload!
       end
@@ -64,7 +67,7 @@ module Rails
     IRB::HelperMethod.register(:controller, ControllerInstance)
     IRB::HelperMethod.register(:new_session, NewSession)
     IRB::HelperMethod.register(:app, AppInstance)
-    IRB::HelperMethod.register(:reload!, ReloadHelper)
+    IRB::Command.register(:reload!, Reloader)
 
     class IRBConsole
       def initialize(app)

data/lib/rails/commands/credentials/USAGE

@@ -38,8 +38,8 @@ Set up Git to Diff Credentials:
     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
+    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) %>`.
 
     Otherwise each co-worker would have to run enable manually, including on each new
@@ -48,8 +48,8 @@ Set up Git to Diff Credentials:
     To disenroll from this feature, run `<%= executable(:diff) %> --disenroll`.
 
 Editing Credentials:
-    This will open a temporary file in `$VISUAL` or `$EDITOR` with the decrypted
-    contents to edit the encrypted credentials.
+    `<%= executable(:edit) %>` will open a temporary file in `$VISUAL` or `$EDITOR`
+    with the decrypted contents to edit 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

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

@@ -128,7 +128,11 @@ module Rails
         end
 
         def extract_environment_from_path(path)
-          available_environments.find { |env| path.end_with?("#{env}.yml.enc") }
+          available_environments.find { |env| path.end_with?("#{env}.yml.enc") } || extract_custom_environment(path)
+        end
+
+        def extract_custom_environment(path)
+          path =~ %r{config/credentials/(.+)\.yml\.enc} && $1
         end
     end
   end

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

@@ -5,7 +5,7 @@ require "rails/dev_caching"
 module Rails
   module Command
     class DevCommand < Base # :nodoc:
-      desc "cache", "Toggle development mode caching on/off"
+      desc "cache", "Toggle Action Controller development mode caching on/off"
       def cache
         Rails::DevCaching.enable_by_file
       end

data/lib/rails/commands/devcontainer/devcontainer_command.rb

@@ -24,7 +24,7 @@ module Rails
             app_name: Rails.application.railtie_name.chomp("_application"),
             database: !!defined?(ActiveRecord) && database,
             active_storage: !!defined?(ActiveStorage),
-            redis: !!(defined?(ActionCable) || defined?(ActiveJob)),
+            redis: !!((defined?(ActionCable) && !defined?(SolidCable)) || (defined?(ActiveJob) && !defined?(SolidQueue))),
             system_test: File.exist?("test/application_system_test_case.rb"),
             node: File.exist?(".node-version"),
           }