rubocop-rails 2.19.1 → 2.30.3

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

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #   def change
       #     change_table :users do |t|
-      #       t.remove :name, :string
+      #       t.remove :name, type: :string
       #     end
       #   end
       #
@@ -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.any_block_type? || last_argument.block_pass_type?
               add_offense(node, message: format(MSG, action: 'drop_table(without block)'))
             end
           end
@@ -290,10 +292,10 @@ module RuboCop
           when :change
             false
           when :remove
-            target_rails_version >= 6.1 && all_hash_key?(node.arguments.last, :type)
+            target_rails_version >= 6.1 && all_hash_key?(node.last_argument, :type)
           when :change_default, :change_column_default, :change_table_comment,
                :change_column_comment
-            all_hash_key?(node.arguments.last, :from, :to)
+            all_hash_key?(node.last_argument, :from, :to)
           else
             true
           end
@@ -307,7 +309,7 @@ module RuboCop
 
         def within_reversible_or_up_only_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
-            (ancestor.block_type? && ancestor.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
+            (ancestor.block_type? && ancestor.method?(:reversible)) || ancestor.method?(:up_only)
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # `Style/FileRead`, `Style/FileWrite` and `Rails/RootJoinChain`.
       #
       # @safety
-      #   This cop is unsafe for autocorrection because `Dir`'s `children`, `each_child`, `entries`, and `glob`
+      #   This cop is unsafe for autocorrection because ``Dir``'s `children`, `each_child`, `entries`, and `glob`
       #   methods return string element, but these methods of `Pathname` return `Pathname` element.
       #
       # @example
@@ -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,14 +33,30 @@ 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
+      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_METHODS = %i[children delete each_child empty? entries exist? glob mkdir open rmdir unlink].to_set.freeze
+        DIR_GLOB_METHODS = %i[[] glob].to_set.freeze
+
+        DIR_NON_GLOB_METHODS = %i[
+          children
+          delete
+          each_child
+          empty?
+          entries
+          exist?
+          mkdir
+          open
+          rmdir
+          unlink
+        ].to_set.freeze
+
+        DIR_METHODS = (DIR_GLOB_METHODS + DIR_NON_GLOB_METHODS).freeze
 
         FILE_METHODS = %i[
           atime
@@ -134,7 +152,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = (DIR_METHODS + FILE_METHODS + FILE_TEST_METHODS + FILE_UTILS_METHODS).to_set.freeze
 
-        def_node_matcher :pathname_method, <<~PATTERN
+        # @!method pathname_method_for_ruby_2_5_or_higher(node)
+        def_node_matcher :pathname_method_for_ruby_2_5_or_higher, <<~PATTERN
           {
             (send (const {nil? cbase} :Dir) $DIR_METHODS $_ $...)
             (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
@@ -143,9 +162,19 @@ module RuboCop
           }
         PATTERN
 
+        # @!method pathname_method_for_ruby_2_4_or_lower(node)
+        def_node_matcher :pathname_method_for_ruby_2_4_or_lower, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Dir) $DIR_NON_GLOB_METHODS $_ $...)
+            (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
+            (send (const {nil? cbase} :FileTest) $FILE_TEST_METHODS $_ $...)
+            (send (const {nil? cbase} :FileUtils) $FILE_UTILS_METHODS $_ $...)
+          }
+        PATTERN
+
         def_node_matcher :dir_glob?, <<~PATTERN
           (send
-            (const {cbase nil?} :Dir) :glob ...)
+            (const {cbase nil?} :Dir) DIR_GLOB_METHODS ...)
         PATTERN
 
         def_node_matcher :rails_root_pathname?, <<~PATTERN
@@ -162,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, method)
-                            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
@@ -183,12 +213,20 @@ module RuboCop
           yield(method, path, args, rails_root)
         end
 
-        def build_path_glob_replacement(path, method)
+        def pathname_method(node)
+          if target_ruby_version >= 2.5
+            pathname_method_for_ruby_2_5_or_higher(node)
+          else
+            pathname_method_for_ruby_2_4_or_lower(node)
+          end
+        end
+
+        def build_path_glob_replacement(path)
           receiver = range_between(path.source_range.begin_pos, path.children.first.loc.selector.end_pos).source
 
           argument = path.arguments.one? ? path.first_argument.source : join_arguments(path.arguments)
 
-          "#{receiver}.#{method}(#{argument})"
+          "#{receiver}.glob(#{argument})"
         end
 
         def build_path_replacement(path, method, args)
@@ -199,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,13 +182,13 @@ 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
 
         def persisted_referenced?(assignment)
-          return unless assignment.referenced?
+          return false unless assignment.referenced?
 
           assignment.variable.references.any? do |reference|
             call_to_persisted?(reference.node.parent)
@@ -196,6 +196,8 @@ module RuboCop
         end
 
         def call_to_persisted?(node)
+          node = node.parent.condition if node.parenthesized_call? && node.parent.if_type?
+
           node.send_type? && node.method?(:persisted?)
         end
 
@@ -235,18 +237,23 @@ module RuboCop
 
         def in_condition_or_compound_boolean?(node)
           node = node.block_node || node
-          parent = node.parent
+          parent = node.each_ancestor.find { |ancestor| !ancestor.begin_type? }
           return false unless parent
 
-          operator_or_single_negative?(parent) || (conditional?(parent) && node == parent.condition)
+          operator_or_single_negative?(parent) || (conditional?(parent) && node == deparenthesize(parent.condition))
         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)
+          node = node.children.last while node.begin_type?
+          node
         end
 
         def checked_immediately?(node)
@@ -298,7 +305,7 @@ module RuboCop
 
           node = assignable_node(node)
           method, sibling_index = find_method_with_sibling_index(node.parent)
-          return 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
@@ -317,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)
@@ -331,10 +339,10 @@ module RuboCop
 
         # Check argument signature as no arguments or one hash
         def expected_signature?(node)
-          !node.arguments? ||
-            (node.arguments.one? &&
-              node.method_name != :destroy &&
-              (node.first_argument.hash_type? || !node.first_argument.literal?))
+          return true unless node.arguments?
+          return false if !node.arguments.one? || node.method?(:destroy)
+
+          node.first_argument.hash_type? || !node.first_argument.literal?
         end
       end
     end

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`.'
@@ -74,17 +75,25 @@ module RuboCop
         def on_send(node)
           if add_column_without_comment?(node)
             add_offense(node, message: COLUMN_MSG)
-          elsif create_table?(node)
-            if create_table_without_comment?(node)
-              add_offense(node, message: TABLE_MSG)
-            elsif create_table_column_call_without_comment?(node)
-              add_offense(node.parent.body, message: COLUMN_MSG)
-            end
+          elsif create_table_without_comment?(node)
+            add_offense(node, message: TABLE_MSG)
+          elsif create_table_with_block?(node.parent)
+            check_column_within_create_table_block(node.parent.body)
           end
         end
 
         private
 
+        def check_column_within_create_table_block(node)
+          if node.begin_type?
+            node.child_nodes.each do |child_node|
+              add_offense(child_node, message: COLUMN_MSG) if t_column_without_comment?(child_node)
+            end
+          elsif t_column_without_comment?(node)
+            add_offense(node, message: COLUMN_MSG)
+          end
+        end
+
         def add_column_without_comment?(node)
           add_column?(node) && !add_column_with_comment?(node)
         end
@@ -93,10 +102,8 @@ module RuboCop
           create_table?(node) && !create_table_with_comment?(node)
         end
 
-        def create_table_column_call_without_comment?(node)
-          create_table_with_block?(node.parent) &&
-            t_column?(node.parent.body) &&
-            !t_column_with_comment?(node.parent.body)
+        def t_column_without_comment?(node)
+          t_column?(node) && !t_column_with_comment?(node)
         end
       end
     end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for uses of `select(:column_name)` with `map(&:column_name)`.
+      # These can be replaced with `pluck(:column_name)`.
+      #
+      # There also should be some performance improvement since it skips instantiating the model class for matches.
+      #
+      # @safety
+      #   This cop is unsafe because the model might override the attribute getter.
+      #   Additionally, the model's `after_initialize` hooks are skipped when using `pluck`.
+      #
+      # @example
+      #   # bad
+      #   Model.select(:column_name).map(&:column_name)
+      #
+      #   # good
+      #   Model.pluck(:column_name)
+      #
+      class SelectMap < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred_method>s` instead of `select` with `%<map_method>s`.'
+
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def on_send(node)
+          return unless node.first_argument
+
+          column_name = node.first_argument.source.delete_prefix('&:')
+          return unless (select_node = find_select_node(node, column_name))
+
+          offense_range = select_node.loc.selector.begin.join(node.source_range.end)
+          preferred_method = "pluck(:#{column_name})"
+          message = format(MSG, preferred_method: preferred_method, map_method: node.method_name)
+
+          add_offense(offense_range, message: message) do |corrector|
+            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.call_type? || !select_candidate.method?(:select)
+
+            match_column_name?(select_candidate, column_name)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, select_node, node, preferred_method)
+          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
+        # rubocop:enable Metrics/AbcSize
+
+        def match_column_name?(select_candidate, column_name)
+          return false unless select_candidate.arguments.one?
+          return false unless (first_argument = select_candidate.first_argument)
+
+          argument = case select_candidate.first_argument.type
+                     when :sym
+                       first_argument.source.delete_prefix(':')
+                     when :str
+                       first_argument.value if first_argument.respond_to?(:value)
+                     end
+
+          argument == column_name
+        end
+      end
+    end
+  end
+end

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

@@ -9,6 +9,9 @@ module RuboCop
       #
       # Methods may be ignored from this rule by configuring a `AllowedMethods`.
       #
+      # @safety
+      #   This cop is unsafe if the receiver object is not an Active Record object.
+      #
       # @example
       #   # bad
       #   Article.first.decrement!(:view_count)
@@ -58,12 +61,12 @@ module RuboCop
         def_node_matcher :good_touch?, <<~PATTERN
           {
             (send (const {nil? cbase} :FileUtils) :touch ...)
-            (send _ :touch {true false})
+            (send _ :touch boolean)
           }
         PATTERN
 
         def_node_matcher :good_insert?, <<~PATTERN
-          (send _ {:insert :insert!} _ {
+          (call _ {:insert :insert!} _ {
             !(hash ...)
             (hash <(pair (sym !{:returning :unique_by}) _) ...>)
           } ...)
@@ -97,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
@@ -108,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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Rails
-      #
       # Checks SQL heredocs to use `.squish`.
       #
       # @safety
@@ -69,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)

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
@@ -35,7 +36,7 @@ module RuboCop
         PATTERN
 
         def_node_search :change_column_null?, <<~PATTERN
-          (send nil? :change_column_null {(sym %1) (str %1)} {(sym %2) (str %2)} false)
+          (send nil? :change_column_null %1 %2 false)
         PATTERN
 
         def on_send(node)
@@ -46,9 +47,7 @@ module RuboCop
 
             def_node = node.each_ancestor(:def, :defs).first
             table_node = table_node(node)
-            if def_node && (table_node.nil? || change_column_null?(def_node, table_node.value, column_node.value))
-              return
-            end
+            return if def_node && (table_node.nil? || change_column_null?(def_node, table_node, column_node))
 
             add_offense(node)
           end