rubocop-rails 2.21.2 → 2.23.1

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

@@ -24,40 +24,39 @@ module RuboCop
         RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
 
         def_node_matcher :where_take?, <<~PATTERN
-          (send
-            $(send _ :where
+          (call
+            $(call _ :where
               (hash
                 (pair (sym :id) $_))) :take!)
         PATTERN
 
         def_node_matcher :find_by?, <<~PATTERN
           {
-            (send _ :find_by_id! $_)
-            (send _ :find_by! (hash (pair (sym :id) $_)))
+            (call _ :find_by_id! $_)
+            (call _ :find_by! (hash (pair (sym :id) $_)))
           }
         PATTERN
 
         def on_send(node)
           where_take?(node) do |where, id_value|
             range = where_take_offense_range(node, where)
-            bad_method = build_where_take_bad_method(id_value)
 
-            register_offense(range, id_value, bad_method)
+            register_offense(range, id_value)
           end
 
           find_by?(node) do |id_value|
             range = find_by_offense_range(node)
-            bad_method = build_find_by_bad_method(node, id_value)
 
-            register_offense(range, id_value, bad_method)
+            register_offense(range, id_value)
           end
         end
+        alias on_csend on_send
 
         private
 
-        def register_offense(range, id_value, bad_method)
+        def register_offense(range, id_value)
           good_method = build_good_method(id_value)
-          message = format(MSG, good_method: good_method, bad_method: bad_method)
+          message = format(MSG, good_method: good_method, bad_method: range.source)
 
           add_offense(range, message: message) do |corrector|
             corrector.replace(range, good_method)
@@ -75,19 +74,6 @@ module RuboCop
         def build_good_method(id_value)
           "find(#{id_value.source})"
         end
-
-        def build_where_take_bad_method(id_value)
-          "where(id: #{id_value.source}).take!"
-        end
-
-        def build_find_by_bad_method(node, id_value)
-          case node.method_name
-          when :find_by_id!
-            "find_by_id!(#{id_value.source})"
-          when :find_by!
-            "find_by!(id: #{id_value.source})"
-          end
-        end
       end
     end
   end

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

@@ -60,7 +60,7 @@ module RuboCop
           (block
             (send nil? :with_options
               (hash $...))
-            (args) ...)
+            (args _?) ...)
         PATTERN
 
         def_node_matcher :association_extension_block?, <<~PATTERN

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for use of the helper methods which reference
       # instance variables.
       #
-      # Relying on instance variables makes it difficult to re-use helper
+      # Relying on instance variables makes it difficult to reuse helper
       # methods.
       #
       # If it seems awkward to explicitly pass in each dependent

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

@@ -33,6 +33,7 @@ module RuboCop
 
           add_offense(node.loc.selector)
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -222,7 +222,7 @@ module RuboCop
 
         def with_options_arguments(recv, node)
           blocks = node.each_ancestor(:block).select do |block|
-            block.send_node.command?(:with_options) && same_context_in_with_options?(block.arguments.first, recv)
+            block.send_node.command?(:with_options) && same_context_in_with_options?(block.first_argument, recv)
           end
           blocks.flat_map { |n| n.send_node.arguments }
         end

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

@@ -3,8 +3,13 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks for add_column call with NOT NULL constraint
-      # in migration file.
+      # Checks for add_column call with NOT NULL constraint in migration file.
+      #
+      # `TEXT` can have default values in PostgreSQL, but not in MySQL.
+      # It will automatically detect an adapter from `development` environment
+      # in `config/database.yml` or the environment variable `DATABASE_URL`
+      # when the `Database` option is not set. If the database is MySQL,
+      # this cop ignores offenses for the `TEXT`.
       #
       # @example
       #   # bad
@@ -17,6 +22,8 @@ module RuboCop
       #   add_reference :products, :category
       #   add_reference :products, :category, null: false, default: 1
       class NotNullColumn < Base
+        include DatabaseTypeResolvable
+
         MSG = 'Do not add a NOT NULL column without a default value.'
         RESTRICT_ON_SEND = %i[add_column add_reference].freeze
 
@@ -45,7 +52,10 @@ module RuboCop
 
         def check_add_column(node)
           add_not_null_column?(node) do |type, pairs|
-            return if type.respond_to?(:value) && (type.value == :virtual || type.value == 'virtual')
+            if type.respond_to?(:value)
+              return if type.value == :virtual || type.value == 'virtual'
+              return if (type.value == :text || type.value == 'text') && database == MYSQL
+            end
 
             check_pairs(pairs)
           end

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

@@ -23,6 +23,7 @@ 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} ...)
@@ -39,8 +40,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if node.parent&.call_type?
-          return unless output?(node) || io_output?(node)
+          return if ALLOWED_TYPES.include?(node.parent&.type)
+          return if !output?(node) && !io_output?(node)
 
           range = offense_range(node)
 

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

@@ -28,13 +28,13 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Prefer `pick(%<args>s)` over `pluck(%<args>s).first`.'
+        MSG = 'Prefer `pick(%<args>s)` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[first].freeze
 
         minimum_target_rails_version 6.0
 
         def_node_matcher :pick_candidate?, <<~PATTERN
-          (send (send _ :pluck ...) :first)
+          (call (call _ :pluck ...) :first)
         PATTERN
 
         def on_send(node)
@@ -44,7 +44,7 @@ module RuboCop
             node_selector = node.loc.selector
             range = receiver_selector.join(node_selector)
 
-            add_offense(range, message: message(receiver)) do |corrector|
+            add_offense(range, message: message(receiver, range)) do |corrector|
               first_range = receiver.source_range.end.join(node_selector)
 
               corrector.remove(first_range)
@@ -52,11 +52,12 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(receiver)
-          format(MSG, args: receiver.arguments.map(&:source).join(', '))
+        def message(receiver, current)
+          format(MSG, args: receiver.arguments.map(&:source).join(', '), current: current.source)
         end
       end
     end

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

@@ -38,7 +38,7 @@ module RuboCop
         minimum_target_rails_version 5.0
 
         def_node_matcher :pluck_candidate?, <<~PATTERN
-          ({block numblock} (send _ {:map :collect}) $_argument (send lvar :[] $_key))
+          ({block numblock} (call _ {:map :collect}) $_argument (send lvar :[] $_key))
         PATTERN
 
         def on_block(node)

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

@@ -34,7 +34,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[pluck].freeze
 
         def_node_matcher :pluck_id_call?, <<~PATTERN
-          (send _ :pluck {(sym :id) (send nil? :primary_key)})
+          (call _ :pluck {(sym :id) (send nil? :primary_key)})
         PATTERN
 
         def on_send(node)
@@ -47,6 +47,7 @@ module RuboCop
             corrector.replace(offense_range(node), 'ids')
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -22,10 +22,13 @@ module RuboCop
       # @example
       #   # bad
       #   Post.where(user_id: User.active.pluck(:id))
+      #   Post.where(user_id: User.active.ids)
+      #   Post.where.not(user_id: User.active.pluck(:id))
       #
       #   # good
       #   Post.where(user_id: User.active.select(:id))
       #   Post.where(user_id: active_users.select(:id))
+      #   Post.where.not(user_id: active_users.select(:id))
       #
       # @example EnforcedStyle: conservative (default)
       #   # good
@@ -40,8 +43,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MSG = 'Use `select` instead of `pluck` within `where` query method.'
-        RESTRICT_ON_SEND = %i[pluck].freeze
+        MSG_SELECT = 'Use `select` instead of `pluck` within `where` query method.'
+        MSG_IDS = 'Use `select(:id)` instead of `ids` within `where` query method.'
+        RESTRICT_ON_SEND = %i[pluck ids].freeze
 
         def on_send(node)
           return unless in_where?(node)
@@ -49,17 +53,26 @@ module RuboCop
 
           range = node.loc.selector
 
-          add_offense(range) do |corrector|
-            corrector.replace(range, 'select')
+          if node.method?(:ids)
+            replacement = 'select(:id)'
+            message = MSG_IDS
+          else
+            replacement = 'select'
+            message = MSG_SELECT
+          end
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, replacement)
           end
         end
+        alias on_csend on_send
 
         private
 
         def root_receiver(node)
           receiver = node.receiver
 
-          if receiver&.send_type?
+          if receiver&.call_type?
             root_receiver(receiver)
           else
             receiver

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

@@ -72,7 +72,7 @@ module RuboCop
         end
 
         def task_name(node)
-          first_arg = node.arguments[0]
+          first_arg = node.first_argument
           case first_arg&.type
           when :sym, :str
             first_arg.value.to_sym
@@ -97,7 +97,7 @@ module RuboCop
         end
 
         def with_dependencies?(node)
-          first_arg = node.arguments[0]
+          first_arg = node.first_argument
           return false unless first_arg
 
           if first_arg.hash_type?

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

@@ -3,8 +3,43 @@
 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.
+      # It will ignore cases where the receiver is an association (e.g., `user.articles.all.delete_all`).
+      # This is because omitting `all` from an association changes the methods
+      # from `ActiveRecord::Relation` to `ActiveRecord::Associations::CollectionProxy`,
+      # which can affect their behavior.
+      #
       # @safety
       #   This cop is unsafe for autocorrection if the receiver for `all` is not an Active Record object.
       #
@@ -35,11 +70,19 @@ module RuboCop
 
         RESTRICT_ON_SEND = [:all].freeze
 
-        # Defined methods in `ActiveRecord::Querying::QUERYING_METHODS` on activerecord 7.0.5.
+        # Defined methods in `ActiveRecord::Querying::QUERYING_METHODS` on activerecord 7.1.0.
         QUERYING_METHODS = %i[
           and
           annotate
           any?
+          async_average
+          async_count
+          async_ids
+          async_maximum
+          async_minimum
+          async_pick
+          async_pluck
+          async_sum
           average
           calculate
           count
@@ -109,6 +152,7 @@ module RuboCop
           preload
           readonly
           references
+          regroup
           reorder
           reselect
           rewhere
@@ -130,17 +174,20 @@ module RuboCop
           unscope
           update_all
           where
+          with
           without
         ].to_set.freeze
 
         POSSIBLE_ENUMERABLE_BLOCK_METHODS = %i[any? count find none? one? select sum].freeze
+        SENSITIVE_METHODS_ON_ASSOCIATION = %i[delete_all destroy_all].freeze
 
         def_node_matcher :followed_by_query_method?, <<~PATTERN
           (send (send _ :all) QUERYING_METHODS ...)
         PATTERN
 
         def on_send(node)
-          return if !followed_by_query_method?(node.parent) || possible_enumerable_block_method?(node)
+          return unless followed_by_query_method?(node.parent)
+          return if possible_enumerable_block_method?(node) || sensitive_association_method?(node)
           return if node.receiver ? allowed_receiver?(node.receiver) : !inherit_active_record_base?(node)
 
           range_of_all_method = offense_range(node)
@@ -159,6 +206,10 @@ module RuboCop
           parent.parent&.block_type? || parent.parent&.numblock_type? || parent.first_argument&.block_pass_type?
         end
 
+        def sensitive_association_method?(node)
+          !node.receiver&.const_type? && SENSITIVE_METHODS_ON_ASSOCIATION.include?(node.parent.method_name)
+        end
+
         def offense_range(node)
           range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end

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

@@ -53,6 +53,12 @@ module RuboCop
         #   @example source that matches - by a foreign key
         #     validates :user_id, presence: true
         #
+        #   @example source that DOES NOT match - if condition
+        #     validates :user_id, presence: true, if: condition
+        #
+        #   @example source that DOES NOT match - unless condition
+        #     validates :user_id, presence: true, unless: condition
+        #
         #   @example source that DOES NOT match - strict validation
         #     validates :user_id, presence: true, strict: true
         #
@@ -65,6 +71,7 @@ module RuboCop
             $[
               (hash <$(pair (sym :presence) true) ...>)         # presence: true
               !(hash <$(pair (sym :strict) {true const}) ...>)  # strict: true
+              !(hash <$(pair (sym {:if :unless}) _) ...>)       # if: some_condition or unless: some_condition
             ]
           )
         PATTERN

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

@@ -100,7 +100,7 @@ module RuboCop
                  else
                    return false if node.arguments.empty?
 
-                   arg = node.arguments.first
+                   arg = node.first_argument
                    ->(n) { same_value?(arg, n.receiver) }
                  end
 

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

@@ -3,25 +3,30 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+      # Prefer `response.parsed_body` to custom parsing logic for `response.body`.
       #
       # @safety
-      #   This cop is unsafe because Content-Type may not be `application/json`. For example, the proprietary
-      #   Content-Type provided by corporate entities such as `application/vnd.github+json` is not supported at
-      #   `response.parsed_body` by default, so you still have to use `JSON.parse(response.body)` there.
+      #   This cop is unsafe because Content-Type may not be `application/json` or `text/html`.
+      #   For example, the proprietary Content-Type provided by corporate entities such as
+      #   `application/vnd.github+json` is not supported at `response.parsed_body` by default,
+      #   so you still have to use `JSON.parse(response.body)` there.
       #
       # @example
       #   # bad
       #   JSON.parse(response.body)
       #
+      #   # bad
+      #   Nokogiri::HTML.parse(response.body)
+      #
+      #   # bad
+      #   Nokogiri::HTML5.parse(response.body)
+      #
       #   # good
       #   response.parsed_body
       class ResponseParsedBody < Base
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Prefer `response.parsed_body` to `JSON.parse(response.body)`.'
-
         RESTRICT_ON_SEND = %i[parse].freeze
 
         minimum_target_rails_version 5.0
@@ -38,12 +43,27 @@ module RuboCop
           )
         PATTERN
 
+        # @!method nokogiri_html_parse_response_body(node)
+        def_node_matcher :nokogiri_html_parse_response_body, <<~PATTERN
+          (send
+            (const
+              (const {nil? cbase} :Nokogiri)
+              ${:HTML :HTML5}
+            )
+            :parse
+            (send
+              (send nil? :response)
+              :body
+            )
+          )
+        PATTERN
+
         def on_send(node)
-          return unless json_parse_response_body?(node)
+          check_json_parse_response_body(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          return unless target_rails_version >= 7.1
+
+          check_nokogiri_html_parse_response_body(node)
         end
 
         private
@@ -51,6 +71,28 @@ module RuboCop
         def autocorrect(corrector, node)
           corrector.replace(node, 'response.parsed_body')
         end
+
+        def check_json_parse_response_body(node)
+          return unless json_parse_response_body?(node)
+
+          add_offense(
+            node,
+            message: 'Prefer `response.parsed_body` to `JSON.parse(response.body)`.'
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def check_nokogiri_html_parse_response_body(node)
+          return unless (const = nokogiri_html_parse_response_body(node))
+
+          add_offense(
+            node,
+            message: "Prefer `response.parsed_body` to `Nokogiri::#{const}.parse(response.body)`."
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
       end
     end
   end

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

@@ -290,10 +290,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

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

@@ -235,10 +235,10 @@ 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)
@@ -249,6 +249,11 @@ module RuboCop
           parent.if_type? || parent.case_type?
         end
 
+        def deparenthesize(node)
+          node = node.children.last while node.begin_type?
+          node
+        end
+
         def checked_immediately?(node)
           node.parent && call_to_persisted?(node.parent)
         end
@@ -331,10 +336,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/unique_validation_without_index.rb

@@ -124,7 +124,7 @@ module RuboCop
         end
 
         def uniqueness_part(node)
-          pairs = node.arguments.last
+          pairs = node.last_argument
           return unless pairs&.hash_type?
 
           pairs.each_pair.find do |pair|

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

@@ -86,7 +86,11 @@ module RuboCop
         end
 
         def environments
-          cop_config['Environments']
+          @environments ||= begin
+            environments = cop_config['Environments'] || []
+            environments << 'local' if target_rails_version >= 7.1
+            environments
+          end
         end
       end
     end

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

@@ -51,7 +51,7 @@ module RuboCop
           uniqueness
         ].freeze
 
-        RESTRICT_ON_SEND = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
+        RESTRICT_ON_SEND = TYPES.map { |p| :"validates_#{p}_of" }.freeze
         ALLOWLIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
 
         def on_send(node)
@@ -60,7 +60,7 @@ module RuboCop
           range = node.loc.selector
 
           add_offense(range, message: message(node)) do |corrector|
-            last_argument = node.arguments.last
+            last_argument = node.last_argument
             return if !last_argument.literal? && !last_argument.splat_type? && !frozen_array_argument?(last_argument)
 
             corrector.replace(range, 'validates')

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

@@ -33,8 +33,8 @@ module RuboCop
 
         def_node_matcher :where_method_call?, <<~PATTERN
           {
-            (send _ :where (array $str_type? $_ ?))
-            (send _ :where $str_type? $_ ?)
+            (call _ :where (array $str_type? $_ ?))
+            (call _ :where $str_type? $_ ?)
           }
         PATTERN
 
@@ -55,6 +55,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         EQ_ANONYMOUS_RE = /\A([\w.]+)\s+=\s+\?\z/.freeze             # column = ?
         IN_ANONYMOUS_RE = /\A([\w.]+)\s+IN\s+\(\?\)\z/i.freeze       # column IN (?)