railties 6.1.6 → 7.1.2

data/lib/rails/autoloaders.rb

@@ -1,48 +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
+  class Autoloaders # :nodoc:
+    require_relative "autoloaders/inflector"
+
+    include Enumerable
+
+    attr_reader :main, :once
+
+    def initialize
+      # This `require` delays loading the library on purpose.
+      #
+      # In Rails 7.0.0, railties/lib/rails.rb loaded Zeitwerk as a side-effect,
+      # but a couple of edge cases related to Bundler and Bootsnap showed up.
+      # They had to do with order of decoration of `Kernel#require`, something
+      # the three of them do.
+      #
+      # Delaying this `require` up to this point is a convenient trade-off.
+      require "zeitwerk"
+
+      @main = Zeitwerk::Loader.new
+      @main.tag = "rails.main"
+      @main.inflector = Inflector
+
+      @once = Zeitwerk::Loader.new
+      @once.tag = "rails.once"
+      @once.inflector = Inflector
+    end
+
+    def each
+      yield main
+      yield once
+    end
+
+    def logger=(logger)
+      each { |loader| loader.logger = logger }
+    end
+
+    def log!
+      each(&:log!)
+    end
+
+    def zeitwerk_enabled?
+      true
     end
   end
 end

data/lib/rails/backtrace_cleaner.rb

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

data/lib/rails/cli.rb

@@ -10,8 +10,11 @@ require "rails/ruby_version_check"
 Signal.trap("INT") { puts; exit(1) }
 
 require "rails/command"
-
-if ARGV.first == "plugin"
+case ARGV.first
+when Rails::Command::HELP_MAPPINGS, "help", nil
+  ARGV.shift
+  Rails::Command.invoke :gem_help, ARGV
+when "plugin"
   ARGV.shift
   Rails::Command.invoke :plugin, ARGV
 else

data/lib/rails/code_statistics.rb

@@ -3,7 +3,7 @@
 require "rails/code_statistics_calculator"
 require "active_support/core_ext/enumerable"
 
-class CodeStatistics #:nodoc:
+class CodeStatistics # :nodoc:
   TEST_TYPES = ["Controller tests",
                 "Helper tests",
                 "Model tests",
@@ -40,7 +40,7 @@ class CodeStatistics #:nodoc:
       Hash[@pairs.map { |pair| [pair.first, calculate_directory_statistics(pair.last)] }]
     end
 
-    def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|ts|coffee|rake)$/)
+    def calculate_directory_statistics(directory, pattern = /^(?!\.).*?\.(rb|js|ts|css|scss|coffee|rake|erb)$/)
       stats = CodeStatisticsCalculator.new
 
       Dir.foreach(directory) do |file_name|

data/lib/rails/code_statistics_calculator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class CodeStatisticsCalculator #:nodoc:
+class CodeStatisticsCalculator # :nodoc:
   attr_reader :lines, :code_lines, :classes, :methods
 
   PATTERNS = {
@@ -11,6 +11,15 @@ class CodeStatisticsCalculator #:nodoc:
       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*/\*},

data/lib/rails/command/actions.rb

@@ -10,23 +10,21 @@ module Rails
         Dir.chdir(File.expand_path("../..", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
       end
 
-      def require_application_and_environment!
-        require_application!
-        require_environment!
-      end
-
       def require_application!
         require ENGINE_PATH if defined?(ENGINE_PATH)
+        require APP_PATH if defined?(APP_PATH)
+      end
 
-        if defined?(APP_PATH)
-          require APP_PATH
-        end
+      def boot_application!
+        require_application!
+        Rails.application.require_environment! if defined?(APP_PATH)
       end
 
-      def require_environment!
-        if defined?(APP_PATH)
-          Rails.application.require_environment!
-        end
+      def load_environment_config!
+        require_application!
+        # Only run initializers that are in the :all group, which includes the
+        # :load_environment_config initializer.
+        Rails.application.initialize!(:_) if defined?(APP_PATH)
       end
 
       if defined?(ENGINE_PATH)

data/lib/rails/command/base.rb

@@ -3,7 +3,8 @@
 require "thor"
 require "erb"
 
-require "active_support/core_ext/string/filters"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/string/inflections"
 
 require "rails/command/actions"
@@ -16,12 +17,14 @@ module Rails
 
       include Actions
 
+      class_attribute :bin, instance_accessor: false, default: "bin/rails"
+
       class << self
         def exit_on_failure? # :nodoc:
           false
         end
 
-        # Returns true when the app is a Rails engine.
+        # Returns true when the app is a \Rails engine.
         def engine?
           defined?(ENGINE_ROOT)
         end
@@ -32,7 +35,7 @@ module Rails
           if usage
             super
           else
-            @desc ||= ERB.new(File.read(usage_path)).result(binding) if usage_path
+            class_usage
           end
         end
 
@@ -53,7 +56,7 @@ module Rails
           Rails::Command.hidden_commands << self
         end
 
-        def inherited(base) #:nodoc:
+        def inherited(base) # :nodoc:
           super
 
           if base.name && !base.name.end_with?("Base")
@@ -63,33 +66,46 @@ module Rails
 
         def perform(command, args, config) # :nodoc:
           if Rails::Command::HELP_MAPPINGS.include?(args.first)
-            command, args = "help", []
+            command, args = "help", [command]
+            args.clear if instance_method(:help).arity.zero?
           end
 
           dispatch(command, args.dup, nil, config)
         end
 
         def printing_commands
-          namespaced_commands
+          commands.filter_map do |name, command|
+            [namespaced_name(name), command.description] unless command.hidden?
+          end
         end
 
-        def executable
-          "rails #{command_name}"
+        def executable(command_name = self.command_name)
+          "#{bin} #{namespaced_name(command_name)}"
+        end
+
+        def banner(command = nil, *)
+          if command
+            # Similar to Thor's banner, but show the namespace (minus the
+            # "rails:" prefix), and show the command's declared bin instead of
+            # the command runner.
+            command.formatted_usage(self).gsub(/^#{namespace}:(\w+)/) { executable($1) }
+          else
+            executable
+          end
         end
 
-        # Use Rails' default banner.
-        def banner(*)
-          "#{executable} #{arguments.map(&:usage).join(' ')} [options]".squish
+        # Override Thor's class-level help to also show the USAGE.
+        def help(shell, *) # :nodoc:
+          super
+          shell.say class_usage if class_usage
         end
 
         # Sets the base_name taking into account the current class namespace.
         #
         #   Rails::Command::TestCommand.base_name # => 'rails'
         def base_name
-          @base_name ||= begin
-            if base = name.to_s.split("::").first
-              base.underscore
-            end
+          @base_name ||= if base = name.to_s.split("::").first
+            base.underscore
           end
         end
 
@@ -97,20 +113,22 @@ module Rails
         #
         #   Rails::Command::TestCommand.command_name # => 'test'
         def command_name
-          @command_name ||= begin
-            if command = name.to_s.split("::").last
-              command.chomp!("Command")
-              command.underscore
-            end
+          @command_name ||= if command = name.to_s.split("::").last
+            command.chomp!("Command")
+            command.underscore
+          end
+        end
+
+        def class_usage # :nodoc:
+          if usage_path
+            @class_usage ||= ERB.new(File.read(usage_path), trim_mode: "-").result(binding)
           end
         end
 
         # Path to lookup a USAGE description in a file.
         def usage_path
-          if default_command_root
-            path = File.join(default_command_root, "USAGE")
-            path if File.exist?(path)
-          end
+          @usage_path = resolve_path("USAGE") unless defined?(@usage_path)
+          @usage_path
         end
 
         # Default file root to place extra files a command might need, placed
@@ -119,8 +137,8 @@ module Rails
         # For a Rails::Command::TestCommand placed in <tt>rails/command/test_command.rb</tt>
         # would return <tt>rails/test</tt>.
         def default_command_root
-          path = File.expand_path(relative_command_path, __dir__)
-          path if File.exist?(path)
+          @default_command_root = resolve_path(".") unless defined?(@default_command_root)
+          @default_command_root
         end
 
         private
@@ -131,37 +149,35 @@ module Rails
             else
               # Prevent exception about command without usage.
               # Some commands define their documentation differently.
-              @usage ||= ""
+              @usage ||= meth
               @desc  ||= ""
 
               super
             end
           end
 
-          def command_root_namespace
-            (namespace.split(":") - %w(rails)).join(":")
+          def namespaced_name(name)
+            *prefix, basename = namespace.delete_prefix("rails:").split(":")
+            prefix.concat([basename, name.to_s].uniq).join(":")
           end
 
-          def relative_command_path
-            File.join("../commands", *command_root_namespace.split(":"))
-          end
-
-          def namespaced_commands
-            commands.keys.map do |key|
-              if command_root_namespace.match?(/(\A|\:)#{key}\z/)
-                command_root_namespace
-              else
-                "#{command_root_namespace}:#{key}"
-              end
-            end
+          def resolve_path(path)
+            path = File.join("../commands", *namespace.delete_prefix("rails:").split(":"), path)
+            path = File.expand_path(path, __dir__)
+            path if File.exist?(path)
           end
       end
 
-      def help
-        if command_name = self.class.command_name
-          self.class.command_help(shell, command_name)
-        else
+      no_commands do
+        delegate :executable, to: :class
+        attr_reader :current_subcommand
+
+        def invoke_command(command, *) # :nodoc:
+          @current_subcommand ||= nil
+          original_subcommand, @current_subcommand = @current_subcommand, command.name
           super
+        ensure
+          @current_subcommand = original_subcommand
         end
       end
     end

data/lib/rails/command/behavior.rb

@@ -4,7 +4,7 @@ require "active_support"
 
 module Rails
   module Command
-    module Behavior #:nodoc:
+    module Behavior # :nodoc:
       extend ActiveSupport::Concern
 
       class_methods do

data/lib/rails/command/environment_argument.rb

@@ -5,35 +5,51 @@ require "active_support/core_ext/class/attribute"
 
 module Rails
   module Command
-    module EnvironmentArgument #:nodoc:
+    module EnvironmentArgument # :nodoc:
       extend ActiveSupport::Concern
 
       included do
-        no_commands do
-          class_attribute :environment_desc, default: "Specifies the environment to run this #{self.command_name} under (test/development/production)."
+        class_option :environment, aliases: "-e", type: :string,
+          desc: "The environment to run `#{self.command_name}` in (e.g. test / development / production)."
+      end
+
+      def initialize(...)
+        super
+
+        @environment_specified = options[:environment].present?
+
+        if !@environment_specified
+          self.options = options.merge(environment: Rails::Command.environment)
+        elsif !available_environments.include?(options[:environment])
+          self.options = options.merge(environment: expand_environment_name(options[:environment]))
         end
-        class_option :environment, aliases: "-e", type: :string, desc: environment_desc
       end
 
       private
-        def extract_environment_option_from_argument(default_environment: Rails::Command.environment)
-          if options[:environment]
-            self.options = options.merge(environment: acceptable_environment(options[:environment]))
-          else
-            self.options = options.merge(environment: default_environment)
-          end
+        def require_application!
+          ENV["RAILS_ENV"] = environment
+          super
+        end
+
+        def environment
+          @environment ||= options[:environment]
+        end
+
+        def environment=(environment)
+          @environment = environment
         end
 
-        def acceptable_environment(env = nil)
-          if available_environments.include? env
-            env
-          else
-            %w( production development test ).detect { |e| /^#{env}/.match?(e) } || env
-          end
+        def environment_specified?
+          @environment_specified
         end
 
         def available_environments
-          Dir["config/environments/*.rb"].map { |fname| File.basename(fname, ".*") }
+          @available_environments ||=
+            Dir["config/environments/*.rb"].map { |filename| File.basename(filename, ".*") }
+        end
+
+        def expand_environment_name(name)
+          %w[production development test].find { |full_name| full_name.start_with?(name) } || name
         end
     end
   end

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "shellwords"
 require "active_support/encrypted_file"
 
 module Rails
@@ -7,27 +8,31 @@ module Rails
     module Helpers
       module Editor
         private
-          def ensure_editor_available(command:)
-            if ENV["EDITOR"].to_s.empty?
-              say "No $EDITOR to open file in. Assign one like this:"
+          def editor
+            ENV["VISUAL"].to_s.empty? ? ENV["EDITOR"] : ENV["VISUAL"]
+          end
+
+          def display_hint_if_system_editor_not_specified
+            if editor.to_s.empty?
+              say "No $VISUAL or $EDITOR to open file in. Assign one like this:"
               say ""
-              say %(EDITOR="mate --wait" #{command})
+              say %(VISUAL="mate --wait" #{executable(current_subcommand)})
               say ""
-              say "For editors that fork and exit immediately, it's important to pass a wait flag,"
-              say "otherwise the credentials will be saved immediately with no chance to edit."
+              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."
 
-              false
-            else
               true
             end
           end
 
-          def catch_editing_exceptions
-            yield
+          def system_editor(file_path)
+            system(*Shellwords.split(editor), file_path.to_s)
+          end
+
+          def using_system_editor
+            display_hint_if_system_editor_not_specified || yield
           rescue Interrupt
             say "Aborted changing file: nothing saved."
-          rescue ActiveSupport::EncryptedFile::MissingKeyError => error
-            say error.message
           end
       end
     end