railties 7.1.5.1 → 7.2.2.1

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

@@ -4,14 +4,6 @@ require "rails/command/environment_argument"
 
 module Rails
   class Console
-    module BacktraceCleaner
-      def filter_backtrace(bt)
-        if result = super
-          Rails.backtrace_cleaner.filter([result]).first
-        end
-      end
-    end
-
     def self.start(*args)
       new(*args).start
     end
@@ -32,16 +24,8 @@ module Rails
       app.load_console
 
       @console = app.config.console || begin
-        require "irb"
-        require "irb/completion"
-
-        IRB::WorkSpace.prepend(BacktraceCleaner)
-
-        if !Rails.env.local?
-          ENV["IRB_USE_AUTOCOMPLETE"] ||= "false"
-        end
-
-        IRB
+        require "rails/commands/console/irb_console"
+        IRBConsole.new(app)
       end
     end
 
@@ -72,9 +56,6 @@ module Rails
         puts "Loading #{Rails.env} environment (Rails #{Rails.version})"
       end
 
-      if defined?(console::ExtendCommandBundle)
-        console::ExtendCommandBundle.include(Rails::ConsoleMethods)
-      end
       console.start
     end
   end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "irb/helper_method"
+require "irb/command"
+
+module Rails
+  class Console
+    class RailsHelperBase < IRB::HelperMethod::Base
+      include ConsoleMethods
+    end
+
+    class ControllerHelper < RailsHelperBase
+      description "Gets helper methods available to ApplicationController."
+
+      # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
+      def execute
+        ApplicationController.helpers
+      end
+    end
+
+    class ControllerInstance < RailsHelperBase
+      description "Gets a new instance of ApplicationController."
+
+      # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
+      def execute
+        @controller ||= ApplicationController.new
+      end
+    end
+
+    class NewSession < RailsHelperBase
+      description "[Deprecated] Please use `app(true)` instead."
+
+      def execute(*)
+        app = Rails.application
+        session = ActionDispatch::Integration::Session.new(app)
+
+        # This makes app.url_for and app.foo_path available in the console
+        session.extend(app.routes.url_helpers)
+        session.extend(app.routes.mounted_helpers)
+
+        session
+      end
+    end
+
+    class AppInstance < NewSession
+      description "Creates a new ActionDispatch::Integration::Session and memoizes it. Use `app(true)` to create a new instance."
+
+      def execute(create = false)
+        @app_integration_instance = nil if create
+        @app_integration_instance ||= super
+      end
+    end
+
+    class ReloadHelper < RailsHelperBase
+      description "Reloads the Rails application."
+
+      def execute
+        puts "Reloading..."
+        Rails.application.reloader.reload!
+      end
+    end
+
+    class ReloadCommand < IRB::Command::Base
+      include ConsoleMethods
+
+      category "Rails console"
+      description "Reloads the Rails application."
+
+      def execute(*)
+        puts "Reloading..."
+        Rails.application.reloader.reload!
+      end
+    end
+
+    IRB::HelperMethod.register(:helper, ControllerHelper)
+    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!, ReloadCommand)
+
+    class IRBConsole
+      def initialize(app)
+        @app = app
+
+        require "irb"
+        require "irb/completion"
+      end
+
+      def name
+        "IRB"
+      end
+
+      def start
+        IRB.setup(nil)
+
+        if !Rails.env.local? && !ENV.key?("IRB_USE_AUTOCOMPLETE")
+          IRB.conf[:USE_AUTOCOMPLETE] = false
+        end
+
+        env = colorized_env
+        prompt_prefix = "%N(#{env})"
+        IRB.conf[:IRB_NAME] = @app.name
+
+        IRB.conf[:PROMPT][:RAILS_PROMPT] = {
+          PROMPT_I: "#{prompt_prefix}> ",
+          PROMPT_S: "#{prompt_prefix}%l ",
+          PROMPT_C: "#{prompt_prefix}* ",
+          RETURN: "=> %s\n"
+        }
+
+        if current_filter = IRB.conf[:BACKTRACE_FILTER]
+          IRB.conf[:BACKTRACE_FILTER] = -> (backtrace) do
+            backtrace = current_filter.call(backtrace)
+            Rails.backtrace_cleaner.filter(backtrace)
+          end
+        else
+          IRB.conf[:BACKTRACE_FILTER] = -> (backtrace) do
+            Rails.backtrace_cleaner.filter(backtrace)
+          end
+        end
+
+        # Because some users/libs use Rails::ConsoleMethods to extend Rails console,
+        # we still include it for backward compatibility.
+        IRB::ExtendCommandBundle.include ConsoleMethods
+
+        # Respect user's choice of prompt mode.
+        IRB.conf[:PROMPT_MODE] = :RAILS_PROMPT if IRB.conf[:PROMPT_MODE] == :DEFAULT
+        IRB::Irb.new.run(IRB.conf)
+      end
+
+      def colorized_env
+        case Rails.env
+        when "development"
+          IRB::Color.colorize("dev", [:BLUE])
+        when "test"
+          IRB::Color.colorize("test", [:BLUE])
+        when "production"
+          IRB::Color.colorize("prod", [:RED])
+        else
+          Rails.env
+        end
+      end
+    end
+  end
+end

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

@@ -20,8 +20,8 @@ module Rails
         load_generators
 
         if environment_specified?
-          @content_path = "config/credentials/#{environment}.yml.enc" unless config.key?(:content_path)
-          @key_path = "config/credentials/#{environment}.key" unless config.key?(:key_path)
+          @content_path = "config/credentials/#{environment}.yml.enc" unless config.overridden?(:content_path)
+          @key_path = "config/credentials/#{environment}.key" unless config.overridden?(:key_path)
         end
 
         ensure_encryption_key_has_been_added

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

@@ -16,28 +16,29 @@ module Rails
 
     def start
       adapter_class.dbconsole(db_config, @options)
-    rescue NotImplementedError
-      abort "Unknown command-line client for #{db_config.database}."
+    rescue NotImplementedError, ActiveRecord::AdapterNotFound, LoadError => error
+      abort error.message
     end
 
     def db_config
-      return @db_config if defined?(@db_config)
-
-      # If the user provided a database, use that. Otherwise find
-      # the first config in the database.yml
-      if database
-        @db_config = configurations.configs_for(env_name: environment, name: database, include_hidden: true)
-      else
-        @db_config = configurations.find_db_config(environment)
-      end
+      @db_config ||= begin
+        # If the user provided a database, use that. Otherwise find
+        # the first config in the database.yml
+        config = if database
+          @db_config = configurations.configs_for(env_name: environment, name: database, include_hidden: true)
+        else
+          @db_config = configurations.find_db_config(environment)
+        end
 
-      unless @db_config
-        missing_db = database ? "'#{database}' database is not" : "No databases are"
-        raise ActiveRecord::AdapterNotSpecified,
-          "#{missing_db} configured for '#{environment}'. Available configuration: #{configurations.inspect}"
-      end
+        unless config
+          missing_db = database ? "'#{database}' database is not" : "No databases are"
+          raise ActiveRecord::AdapterNotSpecified,
+            "#{missing_db} configured for '#{environment}'. Available configuration: #{configurations.inspect}"
+        end
 
-      @db_config
+        config.validate!
+        config
+      end
     end
 
     def database
@@ -50,11 +51,9 @@ module Rails
 
     private
       def adapter_class
-        if ActiveRecord::Base.respond_to?(db_config.adapter_class_method)
-          ActiveRecord::Base.public_send(db_config.adapter_class_method)
-        else
-          ActiveRecord::ConnectionAdapters::AbstractAdapter
-        end
+        ActiveRecord::ConnectionAdapters.resolve(db_config.adapter)
+      rescue LoadError
+        ActiveRecord::ConnectionAdapters::AbstractAdapter
       end
 
       def configurations # :doc:
@@ -62,14 +61,6 @@ module Rails
         ActiveRecord::Base.configurations = Rails.application.config.database_configuration
         ActiveRecord::Base.configurations
       end
-
-      def find_cmd_and_exec(commands, *args) # :doc:
-        Rails.deprecator.warn(<<~MSG.squish)
-          Rails::DBConsole#find_cmd_and_exec is deprecated and will be removed in Rails 7.2.
-          Please use find_cmd_and_exec on the connection adapter class instead.
-        MSG
-        ActiveRecord::Base.connection.find_cmd_and_exec(commands, *args)
-      end
   end
 
   module Command

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/devcontainer/devcontainer_generator"
+
+module Rails
+  module Command
+    class DevcontainerCommand < Base # :nodoc:
+      desc "devcontainer", "Generate a Dev Container setup based on current application configuration"
+      def perform(*)
+        boot_application!
+
+        say "Generating Dev Container with the following options:"
+        devcontainer_options.each do |option, value|
+          say "#{option}: #{value}"
+        end
+
+        Rails::Generators::DevcontainerGenerator.new([], devcontainer_options).invoke_all
+      end
+
+      private
+        def devcontainer_options
+          @devcontainer_options ||= {
+            app_name: Rails.application.railtie_name.chomp("_application"),
+            database: !!defined?(ActiveRecord) && database,
+            active_storage: !!defined?(ActiveStorage),
+            redis: !!(defined?(ActionCable) || defined?(ActiveJob)),
+            system_test: File.exist?("test/application_system_test_case.rb"),
+            node: File.exist?(".node-version"),
+          }
+        end
+
+        def database
+          adapter = ActiveRecord::Base.connection_db_config.adapter
+          adapter == "mysql2" ? "mysql" : adapter
+        end
+    end
+  end
+end

data/lib/rails/commands/rake/rake_command.rb

@@ -18,7 +18,7 @@ module Rails
 
         def perform(task, args, config)
           with_rake(task, *args) do |rake|
-            if unrecognized_task = rake.top_level_tasks.find { |task| !rake.lookup(task[/[^\[]+/]) }
+            if unrecognized_task = (rake.top_level_tasks - ["default"]).find { |task| !rake.lookup(task[/[^\[]+/]) }
               @rake_tasks = rake.tasks
               raise UnrecognizedCommandError.new(unrecognized_task)
             end

data/lib/rails/commands/runner/runner_command.rb

@@ -7,6 +7,8 @@ module Rails
     class RunnerCommand < Base # :nodoc:
       include EnvironmentArgument
 
+      class_option :skip_executor, type: :boolean, aliases: "-w", desc: "Don't wrap with Rails Executor", default: false
+
       no_commands do
         def help(command_name = nil, *)
           super
@@ -30,19 +32,20 @@ module Rails
 
         ARGV.replace(command_argv)
 
+        wrap_with_executor = !options[:skip_executor]
         if code_or_file == "-"
-          Rails.application.executor.wrap(source: "application.runner.railties") do
+          conditional_executor(wrap_with_executor, source: "application.runner.railties") do
             eval($stdin.read, TOPLEVEL_BINDING, "stdin")
           end
         elsif File.exist?(code_or_file)
           expanded_file_path = File.expand_path code_or_file
           $0 = expanded_file_path
-          Rails.application.executor.wrap(source: "application.runner.railties") do
+          conditional_executor(wrap_with_executor, source: "application.runner.railties") do
             Kernel.load expanded_file_path
           end
         else
           begin
-            Rails.application.executor.wrap(source: "application.runner.railties") do
+            conditional_executor(wrap_with_executor, source: "application.runner.railties") do
               eval(code_or_file, TOPLEVEL_BINDING, __FILE__, __LINE__)
             end
           rescue SyntaxError, NameError => e
@@ -62,6 +65,14 @@ module Rails
       end
 
       private
+        def conditional_executor(enabled, **args, &block)
+          if enabled
+            Rails.application.executor.wrap(**args, &block)
+          else
+            yield
+          end
+        end
+
         def looks_like_a_file_path?(code_or_file)
           code_or_file.ends_with?(".rb")
         end

data/lib/rails/commands/server/server_command.rb

@@ -114,7 +114,7 @@ module Rails
       class_option :using, aliases: "-u", type: :string,
         desc: "Specify the Rack server used to run the application (thin/puma/webrick).", banner: :name
       class_option :pid, aliases: "-P", type: :string,
-        desc: "Specify the PID file - defaults to #{DEFAULT_PIDFILE}."
+        desc: "Specify the PID file. Defaults to #{DEFAULT_PIDFILE} in development."
       class_option :dev_caching, aliases: "-C", type: :boolean, default: nil,
         desc: "Specify whether to perform caching in development."
       class_option :restart, type: :boolean, default: nil, hide: true
@@ -243,11 +243,13 @@ module Rails
         end
 
         def pid
-          File.expand_path(options[:pid] || ENV.fetch("PIDFILE", DEFAULT_PIDFILE))
+          default_pidfile = environment == "development" ? DEFAULT_PIDFILE : nil
+          pid = options[:pid] || ENV["PIDFILE"] || default_pidfile
+          File.expand_path(pid) if pid
         end
 
         def prepare_restart
-          FileUtils.rm_f(pid) if options[:restart]
+          FileUtils.rm_f(pid) if pid && options[:restart]
         end
 
         def rack_server_suggestion(server)

data/lib/rails/commands/test/test_command.rb

@@ -31,6 +31,8 @@ module Rails
         Rails::TestUnit::Runner.parse_options(args)
         run_prepare_task if self.args.none?(EXACT_TEST_ARGUMENT_PATTERN)
         Rails::TestUnit::Runner.run(args)
+      rescue Rails::TestUnit::InvalidTestError => error
+        raise ArgumentError, error.message
       end
 
       # Define Thor tasks to avoid going through Rake and booting twice when using bin/rails test:*

data/lib/rails/configuration.rb

@@ -131,8 +131,17 @@ module Rails
         @after_generate_callbacks << block
       end
 
+      def apply_rubocop_autocorrect_after_generate!
+        after_generate do |files|
+          parsable_files = files.filter { |file| File.exist?(file) && file.end_with?(".rb") }
+          unless parsable_files.empty?
+            system(RbConfig.ruby, "bin/rubocop", "-A", "--fail-level=E", "--format=quiet", *parsable_files, exception: true)
+          end
+        end
+      end
+
       def method_missing(method, *args)
-        method = method.to_s.delete_suffix("=").to_sym
+        method = method.name.delete_suffix("=").to_sym
 
         if args.empty?
           if method == :rails

data/lib/rails/console/app.rb

@@ -1,35 +1,8 @@
 # frozen_string_literal: true
 
-require "active_support/all"
-require "action_controller"
+Rails.deprecator.warn(<<~MSG, caller_locations(0..1))
+`rails/console/app` has been deprecated and will be removed in Rails 8.0.
+Please require `rails/console/methods` instead.
+MSG
 
-module Rails
-  module ConsoleMethods
-    # reference the global "app" instance, created on demand. To recreate the
-    # instance, pass a non-false value as the parameter.
-    def app(create = false)
-      @app_integration_instance = nil if create
-      @app_integration_instance ||= new_session
-    end
-
-    # create a new session. If a block is given, the new session will be yielded
-    # to the block before being returned.
-    def new_session
-      app = Rails.application
-      session = ActionDispatch::Integration::Session.new(app)
-
-      # This makes app.url_for and app.foo_path available in the console
-      session.extend(app.routes.url_helpers)
-      session.extend(app.routes.mounted_helpers)
-
-      session
-    end
-
-    # reloads the environment
-    def reload!(print = true)
-      puts "Reloading..." if print
-      Rails.application.reloader.reload!
-      true
-    end
-  end
-end
+require "rails/console/methods"

data/lib/rails/console/helpers.rb

@@ -1,19 +1,8 @@
 # frozen_string_literal: true
 
-module Rails
-  module ConsoleMethods
-    # Gets the helper methods available to the controller.
-    #
-    # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
-    def helper
-      ApplicationController.helpers
-    end
+Rails.deprecator.warn(<<~MSG, caller_locations(0..1))
+`rails/console/helpers` has been deprecated and will be removed in Rails 8.0.
+Please require `rails/console/methods` instead.
+MSG
 
-    # Gets a new instance of a controller object.
-    #
-    # This method assumes an +ApplicationController+ exists, and that it extends ActionController::Base.
-    def controller
-      @controller ||= ApplicationController.new
-    end
-  end
-end
+require "rails/console/methods"

data/lib/rails/console/methods.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rails
+  module ConsoleMethods
+    def self.include(_mod, ...)
+      raise_deprecation_warning
+      super
+    end
+
+    def self.method_added(_method_name)
+      raise_deprecation_warning
+      super
+    end
+
+    def self.raise_deprecation_warning
+      Rails.deprecator.warn(<<~MSG, caller_locations(2..2))
+        Extending Rails console through `Rails::ConsoleMethods` is deprecated and will be removed in Rails 8.0.
+        Please directly use IRB's extension API to add new commands or helpers to the console.
+        For more details, please visit: https://github.com/ruby/irb/blob/master/EXTEND_IRB.md
+      MSG
+    end
+  end
+end

data/lib/rails/engine.rb

@@ -451,8 +451,7 @@ module Rails
     # Load console and invoke the registered hooks.
     # Check Rails::Railtie.console for more info.
     def load_console(app = self)
-      require "rails/console/app"
-      require "rails/console/helpers"
+      require "rails/console/methods"
       run_console_blocks(app)
       self
     end
@@ -627,7 +626,7 @@ module Rails
       next if is_a?(Rails::Application)
 
       fixtures = config.root.join("test", "fixtures")
-      if fixtures_in_root_and_not_in_vendor?(fixtures)
+      if fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures)
         ActiveSupport.on_load(:active_record_fixtures) { self.fixture_paths |= ["#{fixtures}/"] }
       end
     end
@@ -644,9 +643,9 @@ module Rails
       end
     end
 
-    initializer :wrap_executor_around_load_seed do |app|
+    initializer :wrap_reloader_around_load_seed do |app|
       self.class.set_callback(:load_seed, :around) do |engine, seeds_block|
-        app.executor.wrap(&seeds_block)
+        app.reloader.wrap(&seeds_block)
       end
     end
 
@@ -735,9 +734,10 @@ module Rails
         end
       end
 
-      def fixtures_in_root_and_not_in_vendor?(fixtures)
+      def fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures)
         fixtures.exist? && fixtures.to_s.start_with?(Rails.root.to_s) &&
-          !fixtures.to_s.start_with?(Rails.root.join("vendor").to_s)
+          !fixtures.to_s.start_with?(Rails.root.join("vendor").to_s) &&
+          !fixtures.to_s.start_with?("#{Rails.root}/.".to_s)
       end
 
       def build_request(env)

data/lib/rails/gem_version.rb

@@ -8,8 +8,8 @@ module Rails
 
   module VERSION
     MAJOR = 7
-    MINOR = 1
-    TINY  = 5
+    MINOR = 2
+    TINY  = 2
     PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")