rubocop-rails 2.26.2 → 2.32.0

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

@@ -29,18 +29,34 @@ 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)))
+            (itblock
+              (call _ :to_h) $:it
+              (array $_ (lvar :it)))
+          }
         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)))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array $_ (lvar :it)))
+            }
             :to_h)
         PATTERN
 
@@ -48,10 +64,19 @@ 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)))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array $_ (lvar :it)))
+            }
+          )
         PATTERN
 
         private

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

@@ -32,18 +32,34 @@ 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) $_))
+            (itblock
+              (call _ :to_h) $:it
+              (array (lvar :it) $_))
+          }
         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) $_))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array (lvar :it) $_))
+            }
             :to_h)
         PATTERN
 
@@ -51,10 +67,19 @@ 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) $_))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array (lvar :it) $_))
+            }
+          )
         PATTERN
 
         private

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

@@ -29,7 +29,7 @@ module RuboCop
         def on_send(node)
           return unless node.arguments.empty?
           return unless (receiver = node.receiver)
-          return if !receiver.str_type? && !receiver.array_type?
+          return unless receiver.type?(:str, :array)
 
           add_offense(node.loc.selector)
         end

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

@@ -115,6 +115,10 @@ module RuboCop
                 $_)))
         PATTERN
 
+        def_node_matcher :delegated_methods, <<~PATTERN
+          (send nil? :delegate (sym $_)+ (hash <(pair (sym :to) _) ...>))
+        PATTERN
+
         def on_send(node)
           methods_node = only_or_except_filter_methods(node)
           return unless methods_node
@@ -139,7 +143,13 @@ module RuboCop
           return [] unless block
 
           defined_methods = block.each_child_node(:def).map(&:method_name)
-          defined_methods + aliased_action_methods(block, defined_methods)
+          defined_methods + delegated_action_methods(block) + aliased_action_methods(block, defined_methods)
+        end
+
+        def delegated_action_methods(node)
+          node.each_child_node(:send).flat_map do |child_node|
+            delegated_methods(child_node) || []
+          end
         end
 
         def aliased_action_methods(node, defined_methods)

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

@@ -23,7 +23,6 @@ module RuboCop
 
         MSG = "Do not write to stdout. Use Rails's logger if you want to log."
         RESTRICT_ON_SEND = %i[ap p pp pretty_print print puts binwrite syswrite write write_nonblock].freeze
-        ALLOWED_TYPES = %i[send csend block numblock].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
@@ -40,7 +39,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if ALLOWED_TYPES.include?(node.parent&.type)
+          return if node.parent&.call_type? || node.block_node
           return if !output?(node) && !io_output?(node)
 
           range = offense_range(node)

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.
       #
@@ -38,30 +56,38 @@ module RuboCop
         minimum_target_rails_version 5.0
 
         def_node_matcher :pluck_candidate?, <<~PATTERN
-          ({block numblock} (call _ {:map :collect}) $_argument (send lvar :[] $_key))
+          (any_block (call _ {:map :collect}) $_argument (send lvar :[] $_key))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize
         def on_block(node)
+          return if node.each_ancestor(:any_block).any?
+
           pluck_candidate?(node) do |argument, key|
             next if key.regexp_type? || !use_one_block_argument?(argument)
 
             match = if node.block_type?
                       block_argument = argument.children.first.source
                       use_block_argument_in_key?(block_argument, key)
-                    else # numblock
-                      argument == 1 && use_block_argument_in_key?('_1', key)
+                    elsif node.numblock_type?
+                      use_block_argument_in_key?('_1', key)
+                    else # itblock
+                      use_block_argument_in_key?('it', key)
                     end
             next unless match
 
             register_offense(node, key)
           end
         end
+        # rubocop:enable Metrics/AbcSize
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def use_one_block_argument?(argument)
-          return true if argument == 1 # Checks for numbered argument `_1`.
+          # Checks for numbered argument `_1` or `it block parameter.
+          return true if [1, :it].include?(argument)
 
           argument.respond_to?(:one?) && argument.one?
         end

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

@@ -96,7 +96,7 @@ module RuboCop
         end
 
         def literal_number?(node)
-          node && (node.int_type? || node.float_type?)
+          node&.type?(:int, :float)
         end
 
         def pluralize(method_name)

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

@@ -102,7 +102,7 @@ module RuboCop
         end
 
         def ignore_other_node?(node)
-          node && (node.if_type? || node.rescue_type? || node.while_type?)
+          node&.type?(:if, :rescue, :while)
         end
 
         def message(node, receiver, other)

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

@@ -110,7 +110,7 @@ module RuboCop
         def on_if(node)
           return unless cop_config['UnlessBlank']
           return unless node.unless?
-          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
+          return if node.else? && config.cop_enabled?('Style/UnlessElse')
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)

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

@@ -174,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_receiver_in_with_options.rb

@@ -85,18 +85,22 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def autocorrect(corrector, send_node, node)
           corrector.remove(send_node.receiver)
           corrector.remove(send_node.loc.dot)
-          corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
+          corrector.remove(block_argument_range(send_node)) if node.block_type?
         end
 
+        # rubocop:disable Metrics/AbcSize
         def redundant_receiver?(send_nodes, node)
           proc = if node.numblock_type?
                    ->(n) { n.receiver.lvar_type? && n.receiver.source == '_1' }
+                 elsif node.itblock_type?
+                   ->(n) { n.receiver.lvar_type? && n.receiver.source == 'it' }
                  else
                    return false if node.arguments.empty?
 
@@ -106,6 +110,7 @@ module RuboCop
 
           send_nodes.all?(&proc)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def block_argument_range(node)
           block_node = node.each_ancestor(:block).first

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

@@ -40,7 +40,7 @@ module RuboCop
 
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
-            return if reflection_class_name.value.send_type? && reflection_class_name.value.receiver.nil?
+            return if reflection_class_name.value.send_type? && !reflection_class_name.value.receiver&.const_type?
             return if reflection_class_name.value.lvar_type? && str_assigned?(reflection_class_name)
 
             add_offense(reflection_class_name) do |corrector|
@@ -76,7 +76,7 @@ module RuboCop
         def autocorrect(corrector, class_config)
           class_value = class_config.value
           replacement = const_or_string(class_value)
-          return unless replacement.present?
+          return unless replacement
 
           corrector.replace(class_value, replacement.source.inspect)
         end

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def nested_relative_date(node, &callback)
-          return if node.nil? || node.block_type?
+          return if node.nil? || node.any_block_type?
 
           node.each_child_node do |child|
             nested_relative_date(child, &callback)

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

@@ -205,6 +205,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -215,8 +216,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.any_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

@@ -237,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

@@ -182,7 +182,7 @@ module RuboCop
         def right_assignment_node(assignment)
           node = assignment.node.child_nodes.first
 
-          return node unless node&.block_type?
+          return node unless node&.any_block_type?
 
           node.send_node
         end
@@ -244,11 +244,11 @@ 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)
-          parent.if_type? || parent.case_type?
+          parent.type?(:if, :case)
         end
 
         def deparenthesize(node)
@@ -305,7 +305,7 @@ module RuboCop
 
           node = assignable_node(node)
           method, sibling_index = find_method_with_sibling_index(node.parent)
-          return false unless method && (method.def_type? || method.block_type?)
+          return false unless method&.type?(:def, :any_block)
 
           method.children.size == node.sibling_index + sibling_index
         end
@@ -324,12 +324,13 @@ module RuboCop
 
         def explicit_return?(node)
           ret = assignable_node(node).parent
-          ret && (ret.return_type? || ret.next_type?)
+          ret&.type?(:return, :next)
         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`.'
@@ -38,7 +39,7 @@ module RuboCop
 
         # @!method comment_present?(node)
         def_node_matcher :comment_present?, <<~PATTERN
-          (hash <(pair {(sym :comment) (str "comment")} (_ [present?])) ...>)
+          (hash <(pair {(sym :comment) (str "comment")} !{nil (str blank?)}) ...>)
         PATTERN
 
         # @!method add_column?(node)

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

@@ -61,7 +61,7 @@ module RuboCop
         def_node_matcher :good_touch?, <<~PATTERN
           {
             (send (const {nil? cbase} :FileUtils) :touch ...)
-            (send _ :touch {true false})
+            (send _ :touch boolean)
           }
         PATTERN
 

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver = node.receiver)
-          return unless receiver.str_type? || receiver.dstr_type?
+          return unless receiver.type?(:str, :dstr)
           return unless receiver.respond_to?(:heredoc?) && receiver.heredoc?
 
           register_offense(node, receiver)