rubocop-rails 2.26.0 → 2.29.1

data/lib/rubocop/cop/rails/index_by.rb

@@ -29,18 +29,28 @@ module RuboCop
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
-          (block
-            (call _ :to_h)
-            (args (arg $_el))
-            (array $_ (lvar _el)))
+          {
+            (block
+              (call _ :to_h)
+              (args (arg $_el))
+              (array $_ (lvar _el)))
+            (numblock
+              (call _ :to_h) $1
+              (array $_ (lvar :_1)))
+          }
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array $_ (lvar _el)))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array $_ (lvar _el)))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array $_ (lvar :_1)))
+            }
             :to_h)
         PATTERN
 
@@ -48,10 +58,16 @@ module RuboCop
           (send
             (const {nil? cbase} :Hash)
             :[]
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array $_ (lvar _el))))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array $_ (lvar _el)))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array $_ (lvar :_1)))
+            }
+          )
         PATTERN
 
         private

data/lib/rubocop/cop/rails/index_with.rb

@@ -32,18 +32,28 @@ module RuboCop
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
-          (block
-            (call _ :to_h)
-            (args (arg $_el))
-            (array (lvar _el) $_))
+          {
+            (block
+              (call _ :to_h)
+              (args (arg $_el))
+              (array (lvar _el) $_))
+            (numblock
+              (call _ :to_h) $1
+              (array (lvar :_1) $_))
+          }
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array (lvar _el) $_))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array (lvar _el) $_))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array (lvar :_1) $_))
+            }
             :to_h)
         PATTERN
 
@@ -51,10 +61,16 @@ module RuboCop
           (send
             (const {nil? cbase} :Hash)
             :[]
-            (block
-              (call _ {:map :collect})
-              (args (arg $_el))
-              (array (lvar _el) $_)))
+            {
+              (block
+                (call _ {:map :collect})
+                (args (arg $_el))
+                (array (lvar _el) $_))
+              (numblock
+                (call _ {:map :collect}) $1
+                (array (lvar :_1) $_))
+            }
+          )
         PATTERN
 
         private

data/lib/rubocop/cop/rails/match_route.rb

@@ -21,11 +21,11 @@ module RuboCop
       #   match 'photos/:id', to: 'photos#show', via: :all
       #
       class MatchRoute < Base
+        include RoutesHelper
         extend AutoCorrector
 
         MSG = 'Use `%<http_method>s` instead of `match` to define a route.'
         RESTRICT_ON_SEND = %i[match].freeze
-        HTTP_METHODS = %i[get post put patch delete].freeze
 
         def_node_matcher :match_method_call?, <<~PATTERN
           (send nil? :match $_ $(hash ...) ?)
@@ -60,14 +60,6 @@ module RuboCop
           end
         end
 
-        def_node_matcher :routes_draw?, <<~PATTERN
-          (send (send _ :routes) :draw)
-        PATTERN
-
-        def within_routes?(node)
-          node.each_ancestor(:block).any? { |a| routes_draw?(a.send_node) }
-        end
-
         def extract_via(node)
           via_pair = via_pair(node)
           return %i[get] unless via_pair

data/lib/rubocop/cop/rails/multiple_route_paths.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for mapping a route with multiple paths, which is deprecated and will be removed in Rails 8.1.
+      #
+      # @example
+      #
+      #   # bad
+      #   get '/users', '/other_path', to: 'users#index'
+      #
+      #   # good
+      #   get '/users', to: 'users#index'
+      #   get '/other_path', to: 'users#index'
+      #
+      class MultipleRoutePaths < Base
+        include RoutesHelper
+        extend AutoCorrector
+
+        MSG = 'Use separate routes instead of combining multiple route paths in a single route.'
+        RESTRICT_ON_SEND = HTTP_METHODS
+
+        IGNORED_ARGUMENT_TYPES = %i[array hash].freeze
+
+        def on_send(node)
+          return unless within_routes?(node)
+
+          route_paths = node.arguments.reject { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
+          return if route_paths.count < 2
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, migrate_to_multiple_routes(node, route_paths))
+          end
+        end
+
+        private
+
+        def migrate_to_multiple_routes(node, route_paths)
+          rest = route_paths.last.source_range.end.join(node.source_range.end).source
+          indentation = ' ' * node.source_range.column
+
+          route_paths.map do |route_path|
+            "#{node.method_name} #{route_path.source}#{rest}"
+          end.join("\n#{indentation}")
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/not_null_column.rb

@@ -41,10 +41,14 @@ module RuboCop
       #   change_column_null :products, :category_id, false
       class NotNullColumn < Base
         include DatabaseTypeResolvable
+        include MigrationsHelper
 
         MSG = 'Do not add a NOT NULL column without a default value.'
         RESTRICT_ON_SEND = %i[add_column add_reference].freeze
 
+        VIRTUAL_TYPE_VALUES = [:virtual, 'virtual'].freeze
+        TEXT_TYPE_VALUES = [:text, 'text'].freeze
+
         def_node_matcher :add_not_null_column?, <<~PATTERN
           (send nil? :add_column _ _ $_ (hash $...))
         PATTERN
@@ -91,8 +95,8 @@ module RuboCop
 
         def check_column(type, pairs)
           if type.respond_to?(:value)
-            return if type.value == :virtual || type.value == 'virtual'
-            return if (type.value == :text || type.value == 'text') && database == MYSQL
+            return if VIRTUAL_TYPE_VALUES.include?(type.value)
+            return if TEXT_TYPE_VALUES.include?(type.value) && database == MYSQL
           end
 
           check_pairs(pairs)

data/lib/rubocop/cop/rails/pluck.rb

@@ -9,6 +9,24 @@ module RuboCop
       # element in an enumerable. When called on an Active Record relation, it
       # results in a more efficient query that only selects the necessary key.
       #
+      # NOTE: If the receiver's relation is not loaded and `pluck` is used inside an iteration,
+      # it may result in N+1 queries because `pluck` queries the database on each iteration.
+      # This cop ignores offenses for `map/collect` when they are suspected to be part of an iteration
+      # to prevent such potential issues.
+      #
+      # [source,ruby]
+      # ----
+      # users = User.all
+      # 5.times do
+      #   users.map { |user| user[:foo] } # Only one query is executed
+      # end
+      #
+      # users = User.all
+      # 5.times do
+      #   users.pluck(:id) # A query is executed on every iteration
+      # end
+      # ----
+      #
       # @safety
       #   This cop is unsafe because model can use column aliases.
       #
@@ -42,6 +60,8 @@ module RuboCop
         PATTERN
 
         def on_block(node)
+          return if node.each_ancestor(:block, :numblock).any?
+
           pluck_candidate?(node) do |argument, key|
             next if key.regexp_type? || !use_one_block_argument?(argument)
 

data/lib/rubocop/cop/rails/pluralization_grammar.rb

@@ -11,7 +11,7 @@ module RuboCop
       #   3.day.ago
       #   1.months.ago
       #   5.megabyte
-      #   1.gigabyte
+      #   1.gigabytes
       #
       #   # good
       #   3.days.ago

data/lib/rubocop/cop/rails/present.rb

@@ -98,8 +98,6 @@ module RuboCop
         end
 
         def on_or(node)
-          return unless cop_config['NilOrEmpty']
-
           exists_and_not_empty?(node) do |var1, var2|
             return unless var1 == var2
 

data/lib/rubocop/cop/rails/redundant_active_record_all_method.rb

@@ -3,35 +3,6 @@
 module RuboCop
   module Cop
     module Rails
-      # TODO: In the future, please support only RuboCop 1.52+ and use `RuboCop::Cop::AllowedReceivers`:
-      #       https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/mixin/allowed_receivers.rb
-      #       At that time, this duplicated module implementation can be removed.
-      module AllowedReceivers
-        def allowed_receiver?(receiver)
-          receiver_name = receiver_name(receiver)
-
-          allowed_receivers.include?(receiver_name)
-        end
-
-        def receiver_name(receiver)
-          return receiver_name(receiver.receiver) if receiver.receiver && !receiver.receiver.const_type?
-
-          if receiver.send_type?
-            if receiver.receiver
-              "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
-            else
-              receiver.method_name.to_s
-            end
-          else
-            receiver.source
-          end
-        end
-
-        def allowed_receivers
-          cop_config.fetch('AllowedReceivers', [])
-        end
-      end
-
       # Detect redundant `all` used as a receiver for Active Record query methods.
       #
       # For the methods `delete_all` and `destroy_all`, this cop will only check cases where the receiver is a model.
@@ -203,7 +174,7 @@ module RuboCop
           parent = node.parent
           return false unless POSSIBLE_ENUMERABLE_BLOCK_METHODS.include?(parent.method_name)
 
-          parent.parent&.block_type? || parent.parent&.numblock_type? || parent.first_argument&.block_pass_type?
+          parent.block_literal? || parent.first_argument&.block_pass_type?
         end
 
         def sensitive_association_method?(node)

data/lib/rubocop/cop/rails/redundant_foreign_key.rb

@@ -40,7 +40,7 @@ module RuboCop
         def on_send(node)
           association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
             if redundant?(node, type, name, options, foreign_key)
-              add_offense(foreign_key_pair.source_range) do |corrector|
+              add_offense(foreign_key_pair) do |corrector|
                 range = range_with_surrounding_space(foreign_key_pair.source_range, side: :left)
                 range = range_with_surrounding_comma(range, :left)
 

data/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb

@@ -78,7 +78,7 @@ module RuboCop
 
           send_nodes.each do |send_node|
             receiver = send_node.receiver
-            add_offense(receiver.source_range) do |corrector|
+            add_offense(receiver) do |corrector|
               autocorrect(corrector, send_node, node)
             end
           end

data/lib/rubocop/cop/rails/reflection_class_name.rb

@@ -43,7 +43,7 @@ module RuboCop
             return if reflection_class_name.value.send_type? && reflection_class_name.value.receiver.nil?
             return if reflection_class_name.value.lvar_type? && str_assigned?(reflection_class_name)
 
-            add_offense(reflection_class_name.source_range) do |corrector|
+            add_offense(reflection_class_name) do |corrector|
               autocorrect(corrector, reflection_class_name)
             end
           end

data/lib/rubocop/cop/rails/request_referer.rb

@@ -34,7 +34,7 @@ module RuboCop
           referer?(node) do
             return unless node.method?(wrong_method_name)
 
-            add_offense(node.source_range) do |corrector|
+            add_offense(node) do |corrector|
               corrector.replace(node, "request.#{style}")
             end
           end

data/lib/rubocop/cop/rails/reversible_migration.rb

@@ -215,8 +215,10 @@ module RuboCop
         end
 
         def check_drop_table_node(node)
+          return unless (last_argument = node.last_argument)
+
           drop_table_call(node) do
-            unless node.parent.block_type? || node.last_argument.block_pass_type?
+            unless node.parent.block_type? || last_argument.block_pass_type?
               add_offense(node, message: format(MSG, action: 'drop_table(without block)'))
             end
           end

data/lib/rubocop/cop/rails/root_pathname_methods.rb

@@ -23,6 +23,8 @@ module RuboCop
       #   File.binread(Rails.root.join('db', 'schema.rb'))
       #   File.write(Rails.root.join('db', 'schema.rb'), content)
       #   File.binwrite(Rails.root.join('db', 'schema.rb'), content)
+      #   Dir.glob(Rails.root.join('db', 'schema.rb'))
+      #   Dir[Rails.root.join('db', 'schema.rb')]
       #
       #   # good
       #   Rails.root.join('db', 'schema.rb').open
@@ -31,12 +33,13 @@ module RuboCop
       #   Rails.root.join('db', 'schema.rb').binread
       #   Rails.root.join('db', 'schema.rb').write(content)
       #   Rails.root.join('db', 'schema.rb').binwrite(content)
+      #   Rails.root.glob("db/schema.rb")
       #
       class RootPathnameMethods < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
         include RangeHelp
 
-        MSG = '`%<rails_root>s` is a `Pathname` so you can just append `#%<method>s`.'
+        MSG = '`%<rails_root>s` is a `Pathname`, so you can use `%<replacement>s`.'
 
         DIR_GLOB_METHODS = %i[[] glob].to_set.freeze
 
@@ -188,13 +191,14 @@ module RuboCop
 
         def on_send(node)
           evidence(node) do |method, path, args, rails_root|
-            add_offense(node, message: format(MSG, method: method, rails_root: rails_root.source)) do |corrector|
-              replacement = if dir_glob?(node)
-                              build_path_glob_replacement(path)
-                            else
-                              build_path_replacement(path, method, args)
-                            end
+            replacement = if dir_glob?(node)
+                            build_path_glob_replacement(path)
+                          else
+                            build_path_replacement(path, method, args)
+                          end
 
+            message = format(MSG, rails_root: rails_root.source, replacement: replacement)
+            add_offense(node, message: message) do |corrector|
               corrector.replace(node, replacement)
             end
           end
@@ -233,7 +237,12 @@ module RuboCop
           end
 
           replacement = "#{path_replacement}.#{method}"
-          replacement += "(#{args.map(&:source).join(', ')})" unless args.empty?
+
+          if args.any?
+            formatted_args = args.map { |arg| arg.array_type? ? "*#{arg.source}" : arg.source }
+            replacement += "(#{formatted_args.join(', ')})"
+          end
+
           replacement
         end
 

data/lib/rubocop/cop/rails/save_bang.rb

@@ -244,7 +244,7 @@ module RuboCop
         end
 
         def operator_or_single_negative?(node)
-          node.or_type? || node.and_type? || single_negative?(node)
+          node.operator_keyword? || single_negative?(node)
         end
 
         def conditional?(parent)
@@ -328,8 +328,9 @@ module RuboCop
         end
 
         def return_value_assigned?(node)
-          assignment = assignable_node(node).parent
-          assignment&.lvasgn_type?
+          return false unless (assignment = assignable_node(node).parent)
+
+          assignment.assignment?
         end
 
         def persist_method?(node, methods = RESTRICT_ON_SEND)

data/lib/rubocop/cop/rails/schema_comment.rb

@@ -23,6 +23,7 @@ module RuboCop
       #
       class SchemaComment < Base
         include ActiveRecordMigrationsHelper
+        include MigrationsHelper
 
         COLUMN_MSG = 'New database column without `comment`.'
         TABLE_MSG = 'New database table without `comment`.'

data/lib/rubocop/cop/rails/select_map.rb

@@ -40,12 +40,13 @@ module RuboCop
             autocorrect(corrector, select_node, node, preferred_method)
           end
         end
+        alias on_csend on_send
 
         private
 
         def find_select_node(node, column_name)
           node.descendants.detect do |select_candidate|
-            next if !select_candidate.send_type? || !select_candidate.method?(:select)
+            next if !select_candidate.call_type? || !select_candidate.method?(:select)
 
             match_column_name?(select_candidate, column_name)
           end
@@ -53,7 +54,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, select_node, node, preferred_method)
-          corrector.remove(select_node.loc.dot || node.loc.dot)
+          corrector.remove(select_node.parent.loc.dot)
           corrector.remove(select_node.loc.selector.begin.join(select_node.source_range.end))
           corrector.replace(node.loc.selector.begin.join(node.source_range.end), preferred_method)
         end

data/lib/rubocop/cop/rails/skips_model_validations.rb

@@ -100,7 +100,8 @@ module RuboCop
         end
 
         def forbidden_methods
-          obsolete_result = cop_config['Blacklist']
+          # TODO: Remove when RuboCop Rails 3 releases.
+          obsolete_result = cop_config['Blacklist'] # rubocop:disable InternalAffairs/UndefinedConfig
           if obsolete_result
             warn '`Blacklist` has been renamed to `ForbiddenMethods`.' unless @displayed_forbidden_warning
             @displayed_forbidden_warning = true
@@ -111,7 +112,8 @@ module RuboCop
         end
 
         def allowed_methods
-          obsolete_result = cop_config['Whitelist']
+          # TODO: Remove when RuboCop Rails 3 releases.
+          obsolete_result = cop_config['Whitelist'] # rubocop:disable InternalAffairs/UndefinedConfig
           if obsolete_result
             warn '`Whitelist` has been renamed to `AllowedMethods`.' unless @displayed_allowed_warning
             @displayed_allowed_warning = true

data/lib/rubocop/cop/rails/squished_sql_heredocs.rb

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def using_squish?(node)
-          node.parent&.send_type? && node.parent&.method?(:squish)
+          node.parent&.send_type? && node.parent.method?(:squish)
         end
 
         def singleline_comments_present?(node)

data/lib/rubocop/cop/rails/strong_parameters_expect.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces the use of `ActionController::Parameters#expect` as a method for strong parameter handling.
+      #
+      # @safety
+      #   This cop's autocorrection is considered unsafe because there are cases where the HTTP status may change
+      #   from 500 to 400 when handling invalid parameters. This change, however, reflects an intentional
+      #   incompatibility introduced for valid reasons by the `expect` method, which aligns better with
+      #   strong parameter conventions.
+      #
+      # @example
+      #
+      #   # bad
+      #   params.require(:user).permit(:name, :age)
+      #   params.permit(user: [:name, :age]).require(:user)
+      #
+      #   # good
+      #   params.expect(user: [:name, :age])
+      #
+      class StrongParametersExpect < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[require permit].freeze
+
+        minimum_target_rails_version 8.0
+
+        def_node_matcher :params_require_permit, <<~PATTERN
+          $(call
+            $(call
+              (send nil? :params) :require _) :permit _+)
+        PATTERN
+
+        def_node_matcher :params_permit_require, <<~PATTERN
+          $(call
+            $(call
+               (send nil? :params) :permit (hash (pair _require_param_name _ )))
+                 :require  _require_param_name)
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+
+          if (permit_method, require_method = params_require_permit(node))
+            range = offense_range(require_method, node)
+            prefer = expect_method(require_method, permit_method)
+            replace_argument = true
+          elsif (require_method, permit_method = params_permit_require(node))
+            range = offense_range(permit_method, node)
+            prefer = "expect(#{permit_method.arguments.map(&:source).join(', ')})"
+            replace_argument = false
+          else
+            return
+          end
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.remove(require_method.receiver.source_range.end.join(require_method.source_range.end))
+            corrector.replace(permit_method.loc.selector, 'expect')
+            if replace_argument
+              corrector.insert_before(permit_method.first_argument, "#{require_key(require_method)}[")
+              corrector.insert_after(permit_method.last_argument, ']')
+            end
+          end
+
+          ignore_node(node)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+        alias on_csend on_send
+
+        private
+
+        def offense_range(method_node, node)
+          method_node.loc.selector.join(node.source_range.end)
+        end
+
+        def expect_method(require_method, permit_method)
+          require_key = require_key(require_method)
+          permit_args = permit_method.arguments.map(&:source).join(', ')
+
+          arguments = "#{require_key}[#{permit_args}]"
+
+          "expect(#{arguments})"
+        end
+
+        def require_key(require_method)
+          if (first_argument = require_method.first_argument).respond_to?(:value)
+            require_arg = first_argument.value
+            separator = ': '
+          else
+            require_arg = first_argument.source
+            separator = ' => '
+          end
+
+          "#{require_arg}#{separator}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/three_state_boolean_column.rb

@@ -18,8 +18,9 @@ module RuboCop
       #   t.boolean :active, default: true, null: false
       #
       class ThreeStateBooleanColumn < Base
-        MSG = 'Boolean columns should always have a default value and a `NOT NULL` constraint.'
+        include MigrationsHelper
 
+        MSG = 'Boolean columns should always have a default value and a `NOT NULL` constraint.'
         RESTRICT_ON_SEND = %i[add_column column boolean].freeze
 
         def_node_matcher :three_state_boolean?, <<~PATTERN