railties 7.1.3.4 → 8.0.1

data/lib/rails/backtrace_cleaner.rb

@@ -5,14 +5,16 @@ require "active_support/core_ext/string/access"
 
 module Rails
   class BacktraceCleaner < ActiveSupport::BacktraceCleaner # :nodoc:
-    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w*\))/
-    RENDER_TEMPLATE_PATTERN = /:in `.*_\w+_{2,3}\d+_\d+'/
+    APP_DIRS_PATTERN = /\A(?:\.\/)?(?:app|config|lib|test|\(\w+(?:-\w+)*\))/
+    RENDER_TEMPLATE_PATTERN = /:in [`'].*_\w+_{2,3}\d+_\d+'/
 
     def initialize
       super
-      @root = "#{Rails.root}/"
       add_filter do |line|
-        line.start_with?(@root) ? line.from(@root.size) : line
+        # We may be called before Rails.root is assigned.
+        # When that happens we fallback to not truncating.
+        @root ||= Rails.root && "#{Rails.root}/"
+        @root && line.start_with?(@root) ? line.from(@root.size) : line
       end
       add_filter do |line|
         if RENDER_TEMPLATE_PATTERN.match?(line)
@@ -23,5 +25,18 @@ module Rails
       end
       add_silencer { |line| !APP_DIRS_PATTERN.match?(line) }
     end
+
+    def clean(backtrace, kind = :silent)
+      return backtrace if ENV["BACKTRACE"]
+
+      super(backtrace, kind)
+    end
+    alias_method :filter, :clean
+
+    def clean_frame(frame, kind = :silent)
+      return frame if ENV["BACKTRACE"]
+
+      super(frame, kind)
+    end
   end
 end

data/lib/rails/cli.rb

@@ -6,7 +6,6 @@ require "rails/app_loader"
 # the rest of this script is not run.
 Rails::AppLoader.exec_app
 
-require "rails/ruby_version_check"
 Signal.trap("INT") { puts; exit(1) }
 
 require "rails/command"

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/command.rb

@@ -23,12 +23,6 @@ module Rails
         super(message)
       end
 
-      if !Exception.method_defined?(:detailed_message)
-        def detailed_message(...)
-          message
-        end
-      end
-
       if defined?(DidYouMean::Correctable) && defined?(DidYouMean::SpellChecker)
         include DidYouMean::Correctable
 

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/rails/app/app_generator"
+
+module Rails
+  module Command
+    module App
+      class UpdateCommand < Base # :nodoc:
+        include Thor::Actions
+        add_runtime_options!
+
+        desc "update", "Update configs and some other initially generated files (or use just update:configs or update:bin)"
+        def perform
+          require_application!
+          Rails.application.deprecators.silenced = true
+
+          configs
+          bin
+          public_directory
+          active_storage
+          display_upgrade_guide_info
+        end
+
+        desc "configs", "Update config files in the application config/ directory", hide: true
+        def configs
+          app_generator.create_boot_file
+          app_generator.update_config_files
+        end
+
+        desc "bin", "Add or update executables in the application bin/ directory", hide: true
+        def bin
+          app_generator.update_bin_files
+        end
+
+        desc "public_directory", "Add or update files in the application public/ directory", hide: true
+        def public_directory
+          app_generator.create_public_files
+        end
+
+        desc "active_storage", "Run the active_storage:update command", hide: true
+        def active_storage
+          app_generator.update_active_storage
+        end
+
+        private
+          def display_upgrade_guide_info
+            say "\nAfter this, check Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html for more details about upgrading your app."
+          end
+
+          def app_generator
+            @app_generator ||= begin
+              gen = Rails::Generators::AppGenerator.new(["rails"], generator_options, destination_root: Rails.root)
+              gen.send(:valid_const?) unless File.exist?(Rails.root.join("config", "application.rb"))
+              gen
+            end
+          end
+
+          def generator_options
+            {
+              api:                 !!Rails.application.config.api_only,
+              update:              true,
+              name:                Rails.application.class.name.chomp("::Application").underscore,
+              skip_active_job:     !defined?(ActiveJob::Railtie),
+              skip_active_record:  !defined?(ActiveRecord::Railtie),
+              skip_active_storage: !defined?(ActiveStorage::Engine),
+              skip_action_mailer:  !defined?(ActionMailer::Railtie),
+              skip_action_mailbox: !defined?(ActionMailbox::Engine),
+              skip_action_text:    !defined?(ActionText::Engine),
+              skip_action_cable:   !defined?(ActionCable::Engine),
+              skip_brakeman:       skip_gem?("brakeman"),
+              skip_rubocop:        skip_gem?("rubocop"),
+              skip_thruster:       skip_gem?("thruster"),
+              skip_test:           !defined?(Rails::TestUnitRailtie),
+              skip_system_test:    Rails.application.config.generators.system_tests.nil?,
+              skip_asset_pipeline: asset_pipeline.nil?,
+              skip_bootsnap:       !defined?(Bootsnap),
+            }.merge(options)
+          end
+
+          def asset_pipeline
+            "propshaft" if defined?(Propshaft::Railtie)
+          end
+
+          def skip_gem?(gem_name)
+            gem gem_name
+            false
+          rescue LoadError
+            true
+          end
+      end
+    end
+  end
+end

data/lib/rails/commands/boot/boot_command.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "rails/command/environment_argument"
+
+module Rails
+  module Command
+    class BootCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      desc "boot", "Boot the application and exit"
+      def perform(*) = boot_application!
+    end
+  end
+end

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