rubocop-rails 2.19.1 → 2.30.3

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

@@ -7,25 +7,37 @@ module RuboCop
       # and can be replaced with `select`.
       #
       # Since `pluck` is an eager method and hits the database immediately,
-      # using `select` helps to avoid additional database queries.
+      # using `select` helps to avoid additional database queries by running as
+      # a subquery.
       #
-      # This cop has two different enforcement modes. When the `EnforcedStyle`
-      # is `conservative` (the default) then only calls to `pluck` on a constant
-      # (i.e. a model class) in the `where` is used as offenses.
+      # This cop has two modes of enforcement. When the `EnforcedStyle` is set
+      # to `conservative` (the default), only calls to `pluck` on a constant
+      # (e.g. a model class) within `where` are considered offenses.
       #
       # @safety
-      #   When the `EnforcedStyle` is `aggressive` then all calls to `pluck` in the
-      #   `where` is used as offenses. This may lead to false positives
-      #   as the cop cannot replace to `select` between calls to `pluck` on an
-      #   `ActiveRecord::Relation` instance vs a call to `pluck` on an `Array` instance.
+      #   When `EnforcedStyle` is set to `aggressive`, all calls to `pluck`
+      #   within `where` are considered offenses. This might lead to false
+      #   positives because the check cannot distinguish between calls to
+      #   `pluck` on an `ActiveRecord::Relation` instance and calls to `pluck`
+      #   on an `Array` instance.
+      #
+      #   Additionally, when using a subquery with the SQL `IN` operator,
+      #   databases like PostgreSQL and MySQL can't optimize complex queries as
+      #   well. They need to scan all records of the outer table against the
+      #   subquery result sequentially, rather than using an index. This can
+      #   cause significant performance issues compared to writing the query
+      #   differently or using `pluck`.
       #
       # @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 +52,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 +62,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/pluralization_grammar.rb

@@ -10,25 +10,39 @@ module RuboCop
       #   # bad
       #   3.day.ago
       #   1.months.ago
+      #   5.megabyte
+      #   1.gigabytes
       #
       #   # good
       #   3.days.ago
       #   1.month.ago
+      #   5.megabytes
+      #   1.gigabyte
       class PluralizationGrammar < Base
         extend AutoCorrector
 
-        SINGULAR_DURATION_METHODS = { second: :seconds,
-                                      minute: :minutes,
-                                      hour: :hours,
-                                      day: :days,
-                                      week: :weeks,
-                                      fortnight: :fortnights,
-                                      month: :months,
-                                      year: :years }.freeze
-
-        RESTRICT_ON_SEND = SINGULAR_DURATION_METHODS.keys + SINGULAR_DURATION_METHODS.values
-
-        PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
+        SINGULAR_METHODS = {
+          second: :seconds,
+          minute: :minutes,
+          hour: :hours,
+          day: :days,
+          week: :weeks,
+          fortnight: :fortnights,
+          month: :months,
+          year: :years,
+          byte: :bytes,
+          kilobyte: :kilobytes,
+          megabyte: :megabytes,
+          gigabyte: :gigabytes,
+          terabyte: :terabytes,
+          petabyte: :petabytes,
+          exabyte: :exabytes,
+          zettabyte: :zettabytes
+        }.freeze
+
+        RESTRICT_ON_SEND = SINGULAR_METHODS.keys + SINGULAR_METHODS.values
+
+        PLURAL_METHODS = SINGULAR_METHODS.invert.freeze
 
         MSG = 'Prefer `%<number>s.%<correct>s`.'
 
@@ -82,19 +96,19 @@ module RuboCop
         end
 
         def literal_number?(node)
-          node && (node.int_type? || node.float_type?)
+          node&.type?(:int, :float)
         end
 
         def pluralize(method_name)
-          SINGULAR_DURATION_METHODS.fetch(method_name.to_sym).to_s
+          SINGULAR_METHODS.fetch(method_name.to_sym).to_s
         end
 
         def singularize(method_name)
-          PLURAL_DURATION_METHODS.fetch(method_name.to_sym).to_s
+          PLURAL_METHODS.fetch(method_name.to_sym).to_s
         end
 
         def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) || PLURAL_DURATION_METHODS.key?(method_name)
+          SINGULAR_METHODS.key?(method_name) || PLURAL_METHODS.key?(method_name)
         end
       end
     end

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

@@ -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
 
@@ -112,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/rake_environment.rb

@@ -45,16 +45,24 @@ module RuboCop
             return if with_dependencies?(task_method)
 
             add_offense(task_method) do |corrector|
-              task_name = task_method.arguments[0]
-              task_dependency = correct_task_dependency(task_name)
-
-              corrector.replace(task_name, task_dependency)
+              if with_arguments?(task_method)
+                new_task_dependency = correct_task_arguments_dependency(task_method)
+                corrector.replace(task_arguments(task_method), new_task_dependency)
+              else
+                task_name = task_method.first_argument
+                new_task_dependency = correct_task_dependency(task_name)
+                corrector.replace(task_name, new_task_dependency)
+              end
             end
           end
         end
 
         private
 
+        def correct_task_arguments_dependency(task_method)
+          "#{task_arguments(task_method).source} => :environment"
+        end
+
         def correct_task_dependency(task_name)
           if task_name.sym_type?
             "#{task_name.source.delete(':|\'|"')}: :environment"
@@ -64,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
@@ -80,8 +88,16 @@ module RuboCop
           end
         end
 
+        def task_arguments(node)
+          node.arguments[1]
+        end
+
+        def with_arguments?(node)
+          node.arguments.size > 1 && node.arguments[1].array_type?
+        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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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.
+      #
+      # @example
+      #   # bad
+      #   User.all.find(id)
+      #   User.all.order(:created_at)
+      #   users.all.where(id: ids)
+      #   user.articles.all.order(:created_at)
+      #
+      #   # good
+      #   User.find(id)
+      #   User.order(:created_at)
+      #   users.where(id: ids)
+      #   user.articles.order(:created_at)
+      #
+      # @example AllowedReceivers: ['ActionMailer::Preview', 'ActiveSupport::TimeZone'] (default)
+      #   # good
+      #   ActionMailer::Preview.all.first
+      #   ActiveSupport::TimeZone.all.first
+      class RedundantActiveRecordAllMethod < Base
+        include ActiveRecordHelper
+        include AllowedReceivers
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant `all` detected.'
+
+        RESTRICT_ON_SEND = [:all].freeze
+
+        # 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
+          create_or_find_by
+          create_or_find_by!
+          create_with
+          delete_all
+          delete_by
+          destroy_all
+          destroy_by
+          distinct
+          eager_load
+          except
+          excluding
+          exists?
+          extending
+          extract_associated
+          fifth
+          fifth!
+          find
+          find_by
+          find_by!
+          find_each
+          find_in_batches
+          find_or_create_by
+          find_or_create_by!
+          find_or_initialize_by
+          find_sole_by
+          first
+          first!
+          first_or_create
+          first_or_create!
+          first_or_initialize
+          forty_two
+          forty_two!
+          fourth
+          fourth!
+          from
+          group
+          having
+          ids
+          in_batches
+          in_order_of
+          includes
+          invert_where
+          joins
+          last
+          last!
+          left_joins
+          left_outer_joins
+          limit
+          lock
+          many?
+          maximum
+          merge
+          minimum
+          none
+          none?
+          offset
+          one?
+          only
+          optimizer_hints
+          or
+          order
+          pick
+          pluck
+          preload
+          readonly
+          references
+          regroup
+          reorder
+          reselect
+          rewhere
+          second
+          second!
+          second_to_last
+          second_to_last!
+          select
+          sole
+          strict_loading
+          sum
+          take
+          take!
+          third
+          third!
+          third_to_last
+          third_to_last!
+          touch_all
+          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 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)
+          add_offense(range_of_all_method) do |collector|
+            collector.remove(range_of_all_method)
+            collector.remove(node.parent.loc.dot)
+          end
+        end
+
+        private
+
+        def possible_enumerable_block_method?(node)
+          parent = node.parent
+          return false unless POSSIBLE_ENUMERABLE_BLOCK_METHODS.include?(parent.method_name)
+
+          parent.block_literal? || 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
+      end
+    end
+  end
+end

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_presence_validation_on_belongs_to.rb

@@ -39,6 +39,9 @@ module RuboCop
         MSG = 'Remove explicit presence validation for %<association>s.'
         RESTRICT_ON_SEND = %i[validates].freeze
 
+        # From https://github.com/rails/rails/blob/7a0bf93b9dd291c7f61121a41b3a813ac8857e6a/activemodel/lib/active_model/validations/validates.rb#L157-L159
+        NON_VALIDATION_OPTIONS = %i[if unless on allow_blank allow_nil strict].freeze
+
         minimum_target_rails_version 5.0
 
         # @!method presence_validation?(node)
@@ -53,6 +56,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 +74,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
@@ -163,6 +173,12 @@ module RuboCop
 
         def on_send(node)
           presence_validation?(node) do |all_keys, options, presence|
+            # If presence is the only validation option and other non-validation options
+            # are present, removing it will cause rails to error.
+            used_option_keys = options.keys.select(&:sym_type?).map(&:value)
+            remaining_validations = used_option_keys - NON_VALIDATION_OPTIONS - [:presence]
+            return if remaining_validations.none? && options.keys.length > 1
+
             keys = non_optional_belongs_to(node.parent, all_keys)
             return if keys.none?
 

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
@@ -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/reflection_class_name.rb

@@ -40,10 +40,10 @@ 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.source_range) do |corrector|
+            add_offense(reflection_class_name) do |corrector|
               autocorrect(corrector, reflection_class_name)
             end
           end

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Rails
-      #
       # Use `assert_not` methods instead of `refute` methods.
       #
       # @example EnforcedStyle: assert_not (default)

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

@@ -53,9 +53,12 @@ module RuboCop
           node.pairs.find { |p| p.key.value.to_sym == :content_type }
         end
 
-        def compatible_content_type?(node)
-          (node && node.value.value == 'text/plain') ||
-            (!node && !cop_config['ContentTypeCompatibility'])
+        def compatible_content_type?(pair_node)
+          if pair_node.nil?
+            !cop_config['ContentTypeCompatibility']
+          elsif pair_node.value.respond_to?(:value)
+            pair_node.value.value == 'text/plain'
+          end
         end
 
         def replacement(rest_options, option_value)

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/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