rubocop-rails 2.25.0 → 2.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cad5e6d0c6f188b6ff87adb04fbfb73c7c574b901de45256eb7fa6e50b7a136d
-  data.tar.gz: c8ab8f1d1c3284054af5847231dd996df24ee5441f638f95bc7e32420a3baf04
+  metadata.gz: c18cefb961b3100a871e2411c7a029244eda6998d793e3ece62aef1adcd4c571
+  data.tar.gz: 24cde448ef91e689e05a2357c1aa0cbcc4d61630f1bb6e7fcaf8999ff7678105
 SHA512:
-  metadata.gz: ea0ebe45e988d115aa45d7bdba2b728b0583e1e2d996d43af424eb8abc17ced35b528741fcc47b8b258de52edd2fb7bc1c92dd609b49ddeeaaaf26bce123e783
-  data.tar.gz: 7eb06cfce19f2a4ba78c6d571c65cf386e211b48ca2c9b5b9ca436ec9055e49f9737cbb3f9ce1b44ab432de87121295439effc59f093446cea88199bd08ba8a4
+  metadata.gz: 7be18be7c11552f4a8d460e4833b57881ec3244d3abc7509ef3f9aa78533e3ff77e0ac60cd1737c608c8a724aed4b37fd1faed06ccb689aabf1e0a21970beef6
+  data.tar.gz: fb09716c5cb563cff4eaa33e68f0657424dce2650a9c7da8e37e6876ee8ee12a942ef2b096cb5604ee5a457a7f951dbd2198d290d0f5e0486c04b36e5a2679bc

data/README.md

@@ -1,7 +1,7 @@
 # RuboCop Rails
 
 [![Gem Version](https://badge.fury.io/rb/rubocop-rails.svg)](https://badge.fury.io/rb/rubocop-rails)
-[![CircleCI](https://circleci.com/gh/rubocop/rubocop-rails.svg?style=svg)](https://circleci.com/gh/rubocop/rubocop-rails)
+[![CI](https://github.com/rubocop/rubocop-rails/actions/workflows/test.yml/badge.svg)](https://github.com/rubocop/rubocop-rails/actions/workflows/test.yml)
 
 A [RuboCop](https://github.com/rubocop/rubocop) extension focused on enforcing Rails best practices and coding conventions.
 

data/config/default.yml

@@ -424,6 +424,14 @@ Rails/EnumHash:
   Include:
     - app/models/**/*.rb
 
+Rails/EnumSyntax:
+  Description: 'Use positional arguments over keyword arguments when defining enums.'
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '2.26'
+  Include:
+    - app/models/**/*.rb
+
 Rails/EnumUniqueness:
   Description: 'Avoid duplicate integers in hash-syntax `enum` declaration.'
   Enabled: true
@@ -1018,8 +1026,9 @@ Rails/SkipsModelValidations:
                  See reference for more information.
   Reference: 'https://guides.rubyonrails.org/active_record_validations.html#skipping-validations'
   Enabled: true
+  Safe: false
   VersionAdded: '0.47'
-  VersionChanged: '2.7'
+  VersionChanged: '2.25'
   ForbiddenMethods:
     - decrement!
     - decrement_counter
@@ -1184,12 +1193,12 @@ Rails/Validation:
     - app/models/**/*.rb
 
 Rails/WhereEquals:
-  Description: 'Pass conditions to `where` as a hash instead of manually constructing SQL.'
+  Description: 'Pass conditions to `where` and `where.not` as a hash instead of manually constructing SQL.'
   StyleGuide: 'https://rails.rubystyle.guide/#hash-conditions'
   Enabled: 'pending'
   SafeAutoCorrect: false
   VersionAdded: '2.9'
-  VersionChanged: '2.10'
+  VersionChanged: '2.26'
 
 Rails/WhereExists:
   Description: 'Prefer `exists?(...)` over `where(...).exists?`.'
@@ -1226,12 +1235,17 @@ Rails/WhereRange:
   Description: 'Use ranges in `where` instead of manually constructing SQL.'
   StyleGuide: 'https://rails.rubystyle.guide/#where-ranges'
   Enabled: pending
+  SafeAutoCorrect: false
   VersionAdded: '2.25'
 
 # Accept `redirect_to(...) and return` and similar cases.
 Style/AndOr:
   EnforcedStyle: conditionals
 
+Style/CollectionCompact:
+  AllowedReceivers:
+    - params
+
 Style/FormatStringToken:
   AllowedMethods:
     - redirect

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

@@ -72,13 +72,13 @@ module RuboCop
           if (node = context.each_ancestor(:if, :rescue).first)
             return false if use_redirect_to?(context)
 
-            context = node
-          elsif context.right_siblings.empty?
-            return true
+            context = node.rescue_type? ? node.parent : node
           end
-          context = context.right_siblings
 
-          context.compact.any? do |render_candidate|
+          siblings = context.right_siblings
+          return true if siblings.empty?
+
+          siblings.compact.any? do |render_candidate|
             render?(render_candidate)
           end
         end

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

@@ -113,8 +113,10 @@ module RuboCop
         MYSQL_COMBINABLE_ALTER_METHODS = %i[rename_column add_index remove_index].freeze
 
         POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[change_default].freeze
+        POSTGRESQL_COMBINABLE_TRANSFORMATIONS_SINCE_6_1 = %i[change_null].freeze
 
         POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[change_column_default].freeze
+        POSTGRESQL_COMBINABLE_ALTER_METHODS_SINCE_6_1 = %i[change_column_null].freeze
 
         def on_def(node)
           return unless support_bulk_alter?
@@ -138,9 +140,9 @@ module RuboCop
           return unless support_bulk_alter?
           return unless node.command?(:change_table)
           return if include_bulk_options?(node)
-          return unless node.block_node
+          return unless (body = node.block_node&.body)
 
-          send_nodes = send_nodes_from_change_table_block(node.block_node.body)
+          send_nodes = send_nodes_from_change_table_block(body)
 
           add_offense_for_change_table(node) if count_transformations(send_nodes) > 1
         end
@@ -196,7 +198,9 @@ module RuboCop
           when MYSQL
             COMBINABLE_ALTER_METHODS + MYSQL_COMBINABLE_ALTER_METHODS
           when POSTGRESQL
-            COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
+            result = COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
+            result += POSTGRESQL_COMBINABLE_ALTER_METHODS_SINCE_6_1 if target_rails_version >= 6.1
+            result
           end
         end
 
@@ -205,7 +209,9 @@ module RuboCop
           when MYSQL
             COMBINABLE_TRANSFORMATIONS + MYSQL_COMBINABLE_TRANSFORMATIONS
           when POSTGRESQL
-            COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
+            result = COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
+            result += POSTGRESQL_COMBINABLE_TRANSFORMATIONS_SINCE_6_1 if target_rails_version >= 6.1
+            result
           end
         end
 

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

@@ -16,7 +16,6 @@ module RuboCop
       #   And `compact_blank!` has different implementations for `Array`, `Hash`, and
       #   `ActionController::Parameters`.
       #   `Array#compact_blank!`, `Hash#compact_blank!` are equivalent to `delete_if(&:blank?)`.
-      #   `ActionController::Parameters#compact_blank!` is equivalent to `reject!(&:blank?)`.
       #   If the cop makes a mistake, autocorrected code may get unexpected behavior.
       #
       # @example
@@ -24,6 +23,8 @@ module RuboCop
       #   # bad
       #   collection.reject(&:blank?)
       #   collection.reject { |_k, v| v.blank? }
+      #   collection.select(&:present?)
+      #   collection.select { |_k, v| v.present? }
       #
       #   # good
       #   collection.compact_blank
@@ -31,8 +32,8 @@ module RuboCop
       #   # bad
       #   collection.delete_if(&:blank?)            # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
       #   collection.delete_if { |_k, v| v.blank? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
-      #   collection.reject!(&:blank?)              # Same behavior as `ActionController::Parameters#compact_blank!`
-      #   collection.reject! { |_k, v| v.blank? }   # Same behavior as `ActionController::Parameters#compact_blank!`
+      #   collection.keep_if(&:present?)            # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.keep_if { |_k, v| v.present? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
       #
       #   # good
       #   collection.compact_blank!
@@ -43,24 +44,38 @@ module RuboCop
         extend TargetRailsVersion
 
         MSG = 'Use `%<preferred_method>s` instead.'
-        RESTRICT_ON_SEND = %i[reject delete_if reject!].freeze
+        RESTRICT_ON_SEND = %i[reject delete_if select keep_if].freeze
 
         minimum_target_rails_version 6.1
 
         def_node_matcher :reject_with_block?, <<~PATTERN
           (block
-            (send _ {:reject :delete_if :reject!})
+            (send _ {:reject :delete_if})
             $(args ...)
             (send
               $(lvar _) :blank?))
         PATTERN
 
         def_node_matcher :reject_with_block_pass?, <<~PATTERN
-          (send _ {:reject :delete_if :reject!}
+          (send _ {:reject :delete_if}
             (block_pass
               (sym :blank?)))
         PATTERN
 
+        def_node_matcher :select_with_block?, <<~PATTERN
+          (block
+            (send _ {:select :keep_if})
+            $(args ...)
+            (send
+              $(lvar _) :present?))
+        PATTERN
+
+        def_node_matcher :select_with_block_pass?, <<~PATTERN
+          (send _ {:select :keep_if}
+            (block-pass
+              (sym :present?)))
+        PATTERN
+
         def on_send(node)
           return unless bad_method?(node)
 
@@ -75,8 +90,10 @@ module RuboCop
 
         def bad_method?(node)
           return true if reject_with_block_pass?(node)
+          return true if select_with_block_pass?(node)
 
-          if (arguments, receiver_in_block = reject_with_block?(node.parent))
+          arguments, receiver_in_block = reject_with_block?(node.parent) || select_with_block?(node.parent)
+          if arguments
             return use_single_value_block_argument?(arguments, receiver_in_block) ||
                    use_hash_value_block_argument?(arguments, receiver_in_block)
           end
@@ -103,7 +120,7 @@ module RuboCop
         end
 
         def preferred_method(node)
-          node.method?(:reject) ? 'compact_blank' : 'compact_blank!'
+          node.method?(:reject) || node.method?(:select) ? 'compact_blank' : 'compact_blank!'
         end
       end
     end

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

@@ -12,10 +12,10 @@ module RuboCop
       # The cop also reports warnings when you are using `to_time` method,
       # because it doesn't know about Rails time zone either.
       #
-      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
+      # Two styles are supported for this cop. When `EnforcedStyle` is `strict`
       # then the Date methods `today`, `current`, `yesterday`, and `tomorrow`
       # are prohibited and the usage of both `to_time`
-      # and 'to_time_in_current_zone' are reported as warning.
+      # and `to_time_in_current_zone` are reported as warning.
       #
       # When `EnforcedStyle` is `flexible` then only `Date.today` is prohibited.
       #

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

@@ -12,6 +12,12 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   enum :status, [:active, :archived]
+      #
+      #   # good
+      #   enum :status, { active: 0, archived: 1 }
+      #
+      #   # bad
       #   enum status: [:active, :archived]
       #
       #   # good
@@ -23,7 +29,11 @@ module RuboCop
         MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. Use hash syntax instead.'
         RESTRICT_ON_SEND = %i[enum].freeze
 
-        def_node_matcher :enum?, <<~PATTERN
+        def_node_matcher :enum_with_array?, <<~PATTERN
+          (send nil? :enum $_ ${array} ...)
+        PATTERN
+
+        def_node_matcher :enum_with_old_syntax?, <<~PATTERN
           (send nil? :enum (hash $...))
         PATTERN
 
@@ -32,17 +42,19 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          enum?(node) do |pairs|
+          target_rails_version >= 7.0 && enum_with_array?(node) do |key, array|
+            add_offense(array, message: message(key)) do |corrector|
+              corrector.replace(array, build_hash(array))
+            end
+          end
+
+          enum_with_old_syntax?(node) do |pairs|
             pairs.each do |pair|
               key, array = array_pair?(pair)
               next unless key
 
-              add_offense(array, message: format(MSG, enum: enum_name(key))) do |corrector|
-                hash = array.children.each_with_index.map do |elem, index|
-                  "#{source(elem)} => #{index}"
-                end.join(', ')
-
-                corrector.replace(array, "{#{hash}}")
+              add_offense(array, message: message(key)) do |corrector|
+                corrector.replace(array, build_hash(array))
               end
             end
           end
@@ -50,6 +62,10 @@ module RuboCop
 
         private
 
+        def message(key)
+          format(MSG, enum: enum_name(key))
+        end
+
         def enum_name(key)
           case key.type
           when :sym, :str
@@ -69,6 +85,13 @@ module RuboCop
             elem.source
           end
         end
+
+        def build_hash(array)
+          hash = array.children.each_with_index.map do |elem, index|
+            "#{source(elem)} => #{index}"
+          end.join(', ')
+          "{#{hash}}"
+        end
       end
     end
   end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for enums written with keyword arguments syntax.
+      #
+      # Defining enums with keyword arguments syntax is deprecated and will be removed in Rails 8.0.
+      # Positional arguments should be used instead:
+      #
+      # @example
+      #   # bad
+      #   enum status: { active: 0, archived: 1 }, _prefix: true
+      #
+      #   # good
+      #   enum :status, { active: 0, archived: 1 }, prefix: true
+      #
+      class EnumSyntax < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 7.0
+
+        MSG = 'Enum defined with keyword arguments in `%<enum>s` enum declaration. Use positional arguments instead.'
+        MSG_OPTIONS = 'Enum defined with deprecated options in `%<enum>s` enum declaration. Remove the `_` prefix.'
+        RESTRICT_ON_SEND = %i[enum].freeze
+        OPTION_NAMES = %w[prefix suffix scopes default].freeze
+
+        def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum (hash $...))
+        PATTERN
+
+        def_node_matcher :enum_with_options?, <<~PATTERN
+          (send nil? :enum $_ ${array hash} $_)
+        PATTERN
+
+        def_node_matcher :enum_values, <<~PATTERN
+          (pair $_ ${array hash})
+        PATTERN
+
+        def_node_matcher :enum_options, <<~PATTERN
+          (pair $_ $_)
+        PATTERN
+
+        def on_send(node)
+          check_and_correct_keyword_args(node)
+          check_enum_options(node)
+        end
+
+        private
+
+        def check_and_correct_keyword_args(node)
+          enum?(node) do |pairs|
+            pairs.each do |pair|
+              key, values = enum_values(pair)
+              next unless key
+
+              correct_keyword_args(node, key, values, pairs[1..])
+            end
+          end
+        end
+
+        def check_enum_options(node)
+          enum_with_options?(node) do |key, _, options|
+            options.children.each do |option|
+              name, = enum_options(option)
+
+              add_offense(name, message: format(MSG_OPTIONS, enum: enum_name_value(key))) if name.source[0] == '_'
+            end
+          end
+        end
+
+        def correct_keyword_args(node, key, values, options)
+          add_offense(values, message: format(MSG, enum: enum_name_value(key))) do |corrector|
+            # TODO: Multi-line autocorrect could be implemented in the future.
+            next if multiple_enum_definitions?(node)
+
+            preferred_syntax = "enum #{enum_name(key)}, #{values.source}#{correct_options(options)}"
+
+            corrector.replace(node, preferred_syntax)
+          end
+        end
+
+        def multiple_enum_definitions?(node)
+          keys = node.first_argument.keys.map { |key| key.source.delete_prefix('_') }
+          filterred_keys = keys.filter { |key| !OPTION_NAMES.include?(key) }
+          filterred_keys.size >= 2
+        end
+
+        def enum_name_value(key)
+          case key.type
+          when :sym, :str
+            key.value
+          else
+            key.source
+          end
+        end
+
+        def enum_name(elem)
+          case elem.type
+          when :str
+            elem.value.dump
+          when :sym
+            elem.value.inspect
+          else
+            elem.source
+          end
+        end
+
+        def correct_options(options)
+          corrected_options = options.map do |pair|
+            name = if pair.key.source[0] == '_'
+                     pair.key.source[1..]
+                   else
+                     pair.key.source
+                   end
+
+            "#{name}: #{pair.value.source}"
+          end.join(', ')
+
+          ", #{corrected_options}" unless corrected_options.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,18 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   enum :status, { active: 0, archived: 0 }
+      #
+      #   # good
+      #   enum :status, { active: 0, archived: 1 }
+      #
+      #   # bad
+      #   enum :status, [:active, :archived, :active]
+      #
+      #   # good
+      #   enum :status, [:active, :archived]
+      #
+      #   # bad
       #   enum status: { active: 0, archived: 0 }
       #
       #   # good
@@ -24,6 +36,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
+          (send nil? :enum $_ ${array hash} ...)
+        PATTERN
+
+        def_node_matcher :enum_with_old_syntax?, <<~PATTERN
           (send nil? :enum (hash $...))
         PATTERN
 
@@ -32,15 +48,17 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          enum?(node) do |pairs|
+          enum?(node) do |key, args|
+            consecutive_duplicates(args.values).each do |item|
+              add_offense(item, message: message(key, item))
+            end
+          end
+
+          enum_with_old_syntax?(node) do |pairs|
             pairs.each do |pair|
               enum_values(pair) do |key, args|
-                items = args.values
-
-                next unless duplicates?(items)
-
-                consecutive_duplicates(items).each do |item|
-                  add_offense(item, message: format(MSG, value: item.source, enum: enum_name(key)))
+                consecutive_duplicates(args.values).each do |item|
+                  add_offense(item, message: message(key, item))
                 end
               end
             end
@@ -57,6 +75,10 @@ module RuboCop
             key.source
           end
         end
+
+        def message(key, item)
+          format(MSG, value: item.source, enum: enum_name(key))
+        end
       end
     end
   end

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

@@ -52,7 +52,7 @@ module RuboCop
           (send
             nil?
             {#{FILTERS.join(' ')}}
-            _
+            ...
             $_)
         PATTERN
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks for calls to `link_to` that contain a
+      # Checks for calls to `link_to`, `link_to_if`, and `link_to_unless` methods that contain a
       # `target: '_blank'` but no `rel: 'noopener'`. This can be a security
       # risk as the loaded page will have control over the previous page
       # and could change its location for phishing purposes.
@@ -24,7 +24,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Specify a `:rel` option containing noopener.'
-        RESTRICT_ON_SEND = %i[link_to].freeze
+        RESTRICT_ON_SEND = %i[link_to link_to_if link_to_unless].freeze
 
         def_node_matcher :blank_target?, <<~PATTERN
           (pair {(sym :target) (str "target")} {(str "_blank") (sym :_blank)})

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

@@ -136,6 +136,8 @@ module RuboCop
 
         def check_change_table(node)
           change_table?(node) do |table|
+            next unless node.body
+
             children = node.body.begin_type? ? node.body.children : [node.body]
             children.each do |child|
               check_add_column_in_change_table(child, table)

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

@@ -7,17 +7,26 @@ 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

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

@@ -10,25 +10,39 @@ module RuboCop
       #   # bad
       #   3.day.ago
       #   1.months.ago
+      #   5.megabyte
+      #   1.gigabyte
       #
       #   # 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`.'
 
@@ -86,15 +100,15 @@ module RuboCop
         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/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)
@@ -170,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/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/root_pathname_methods.rb

@@ -38,7 +38,7 @@ module RuboCop
 
         MSG = '`%<rails_root>s` is a `Pathname` so you can just append `#%<method>s`.'
 
-        DIR_GLOB_METHODS = %i[glob].to_set.freeze
+        DIR_GLOB_METHODS = %i[[] glob].to_set.freeze
 
         DIR_NON_GLOB_METHODS = %i[
           children
@@ -171,7 +171,7 @@ module RuboCop
 
         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
@@ -190,7 +190,7 @@ module RuboCop
           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)
+                              build_path_glob_replacement(path)
                             else
                               build_path_replacement(path, method, args)
                             end
@@ -217,12 +217,12 @@ module RuboCop
           end
         end
 
-        def build_path_glob_replacement(path, method)
+        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)

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)

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

@@ -8,6 +8,7 @@ module RuboCop
       # @example
       #   # bad
       #   validates_acceptance_of :foo
+      #   validates_comparison_of :foo
       #   validates_confirmation_of :foo
       #   validates_exclusion_of :foo
       #   validates_format_of :foo
@@ -22,6 +23,7 @@ module RuboCop
       #   # good
       #   validates :foo, acceptance: true
       #   validates :foo, confirmation: true
+      #   validates :foo, comparison: true
       #   validates :foo, exclusion: true
       #   validates :foo, format: true
       #   validates :foo, inclusion: true
@@ -39,6 +41,7 @@ module RuboCop
 
         TYPES = %w[
           acceptance
+          comparison
           confirmation
           exclusion
           format
@@ -56,11 +59,11 @@ module RuboCop
 
         def on_send(node)
           return if node.receiver
+          return unless (last_argument = node.last_argument)
 
           range = node.loc.selector
 
           add_offense(range, message: message(node)) do |corrector|
-            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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Rails
       # Identifies places where manually constructed SQL
-      # in `where` can be replaced with `where(attribute: value)`.
+      # in `where` and `where.not` can be replaced with
+      # `where(attribute: value)` and `where.not(attribute: value)`.
       #
       # @safety
       #   This cop's autocorrection is unsafe because is may change SQL.
@@ -13,6 +14,7 @@ module RuboCop
       # @example
       #   # bad
       #   User.where('name = ?', 'Gabe')
+      #   User.where.not('name = ?', 'Gabe')
       #   User.where('name = :name', name: 'Gabe')
       #   User.where('name IS NULL')
       #   User.where('name IN (?)', ['john', 'jane'])
@@ -21,6 +23,7 @@ module RuboCop
       #
       #   # good
       #   User.where(name: 'Gabe')
+      #   User.where.not(name: 'Gabe')
       #   User.where(name: nil)
       #   User.where(name: ['john', 'jane'])
       #   User.where(users: { name: 'Gabe' })
@@ -29,25 +32,27 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of manually constructing SQL.'
-        RESTRICT_ON_SEND = %i[where].freeze
+        RESTRICT_ON_SEND = %i[where not].freeze
 
         def_node_matcher :where_method_call?, <<~PATTERN
           {
-            (call _ :where (array $str_type? $_ ?))
-            (call _ :where $str_type? $_ ?)
+            (call _ {:where :not} (array $str_type? $_ ?))
+            (call _ {:where :not} $str_type? $_ ?)
           }
         PATTERN
 
         def on_send(node)
+          return if node.method?(:not) && !where_not?(node)
+
           where_method_call?(node) do |template_node, value_node|
             value_node = value_node.first
 
             range = offense_range(node)
 
-            column_and_value = extract_column_and_value(template_node, value_node)
-            return unless column_and_value
+            column, value = extract_column_and_value(template_node, value_node)
+            return unless value
 
-            good_method = build_good_method(*column_and_value)
+            good_method = build_good_method(node.method_name, column, value)
             message = format(MSG, good_method: good_method)
 
             add_offense(range, message: message) do |corrector|
@@ -73,7 +78,7 @@ module RuboCop
           value =
             case template_node.value
             when EQ_ANONYMOUS_RE, IN_ANONYMOUS_RE
-              value_node.source
+              value_node&.source
             when EQ_NAMED_RE, IN_NAMED_RE
               return unless value_node&.hash_type?
 
@@ -88,15 +93,21 @@ module RuboCop
           [Regexp.last_match(1), value]
         end
 
-        def build_good_method(column, value)
+        def build_good_method(method_name, column, value)
           if column.include?('.')
             table, column = column.split('.')
 
-            "where(#{table}: { #{column}: #{value} })"
+            "#{method_name}(#{table}: { #{column}: #{value} })"
           else
-            "where(#{column}: #{value})"
+            "#{method_name}(#{column}: #{value})"
           end
         end
+
+        def where_not?(node)
+          return false unless (receiver = node.receiver)
+
+          receiver.send_type? && receiver.method?(:where)
+        end
       end
     end
   end

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

@@ -43,10 +43,10 @@ module RuboCop
 
             range = offense_range(node)
 
-            column_and_value = extract_column_and_value(template_node, value_node)
-            return unless column_and_value
+            column, value = extract_column_and_value(template_node, value_node)
+            return unless value
 
-            good_method = build_good_method(node.loc.dot&.source, *column_and_value)
+            good_method = build_good_method(node.loc.dot&.source, column, value)
             message = format(MSG, good_method: good_method)
 
             add_offense(range, message: message) do |corrector|
@@ -72,9 +72,9 @@ module RuboCop
           value =
             case template_node.value
             when NOT_EQ_ANONYMOUS_RE, NOT_IN_ANONYMOUS_RE
-              value_node.source
+              value_node&.source
             when NOT_EQ_NAMED_RE, NOT_IN_NAMED_RE
-              return unless value_node.hash_type?
+              return unless value_node&.hash_type?
 
               pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
               pair.value.source

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

@@ -6,6 +6,14 @@ module RuboCop
       # Identifies places where manually constructed SQL
       # in `where` can be replaced with ranges.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it can change the query
+      #   by explicitly attaching the column to the wrong table.
+      #   For example, `Booking.joins(:events).where('end_at < ?', Time.current)` will correctly
+      #   implicitly attach the `end_at` column to the `events` table. But when autocorrected to
+      #   `Booking.joins(:events).where(end_at: ...Time.current)`, it will now be incorrectly
+      #   explicitly attached to the `bookings` table.
+      #
       # @example
       #   # bad
       #   User.where('age >= ?', 18)
@@ -37,17 +45,17 @@ module RuboCop
         RESTRICT_ON_SEND = %i[where not].freeze
 
         # column >= ?
-        GTEQ_ANONYMOUS_RE   = /\A([\w.]+)\s+>=\s+\?\z/.freeze
+        GTEQ_ANONYMOUS_RE   = /\A\s*([\w.]+)\s+>=\s+\?\s*\z/.freeze
         # column <[=] ?
-        LTEQ_ANONYMOUS_RE   = /\A([\w.]+)\s+(<=?)\s+\?\z/.freeze
+        LTEQ_ANONYMOUS_RE   = /\A\s*([\w.]+)\s+(<=?)\s+\?\s*\z/.freeze
         # column >= ? AND column <[=] ?
-        RANGE_ANONYMOUS_RE  = /\A([\w.]+)\s+>=\s+\?\s+AND\s+\1\s+(<=?)\s+\?\z/i.freeze
+        RANGE_ANONYMOUS_RE  = /\A\s*([\w.]+)\s+>=\s+\?\s+AND\s+\1\s+(<=?)\s+\?\s*\z/i.freeze
         # column >= :value
-        GTEQ_NAMED_RE       = /\A([\w.]+)\s+>=\s+:(\w+)\z/.freeze
+        GTEQ_NAMED_RE       = /\A\s*([\w.]+)\s+>=\s+:(\w+)\s*\z/.freeze
         # column <[=] :value
-        LTEQ_NAMED_RE       = /\A([\w.]+)\s+(<=?)\s+:(\w+)\z/.freeze
+        LTEQ_NAMED_RE       = /\A\s*([\w.]+)\s+(<=?)\s+:(\w+)\s*\z/.freeze
         # column >= :value1 AND column <[=] :value2
-        RANGE_NAMED_RE      = /\A([\w.]+)\s+>=\s+:(\w+)\s+AND\s+\1\s+(<=?)\s+:(\w+)\z/i.freeze
+        RANGE_NAMED_RE      = /\A\s*([\w.]+)\s+>=\s+:(\w+)\s+AND\s+\1\s+(<=?)\s+:(\w+)\s*\z/i.freeze
 
         minimum_target_ruby_version 2.6
         minimum_target_rails_version 6.0
@@ -86,47 +94,63 @@ module RuboCop
 
         # rubocop:disable Metrics
         def extract_column_and_value(template_node, values_node)
-          value =
-            case template_node.value
-            when GTEQ_ANONYMOUS_RE
-              "#{values_node[0].source}.."
-            when LTEQ_ANONYMOUS_RE
-              range_operator = range_operator(Regexp.last_match(2))
-              "#{range_operator}#{values_node[0].source}" if target_ruby_version >= 2.7
-            when RANGE_ANONYMOUS_RE
-              if values_node.size >= 2
-                range_operator = range_operator(Regexp.last_match(2))
-                "#{values_node[0].source}#{range_operator}#{values_node[1].source}"
-              end
-            when GTEQ_NAMED_RE
-              value_node = values_node[0]
+          case template_node.value
+          when GTEQ_ANONYMOUS_RE
+            lhs = values_node[0]
+            operator = '..'
+          when LTEQ_ANONYMOUS_RE
+            if target_ruby_version >= 2.7
+              operator = range_operator(Regexp.last_match(2))
+              rhs = values_node[0]
+            end
+          when RANGE_ANONYMOUS_RE
+            if values_node.size >= 2
+              lhs = values_node[0]
+              operator = range_operator(Regexp.last_match(2))
+              rhs = values_node[1]
+            end
+          when GTEQ_NAMED_RE
+            value_node = values_node[0]
 
-              if value_node.hash_type?
-                pair = find_pair(value_node, Regexp.last_match(2))
-                "#{pair.value.source}.." if pair
-              end
-            when LTEQ_NAMED_RE
-              value_node = values_node[0]
-
-              if value_node.hash_type?
-                pair = find_pair(value_node, Regexp.last_match(2))
-                if pair && target_ruby_version >= 2.7
-                  range_operator = range_operator(Regexp.last_match(2))
-                  "#{range_operator}#{pair.value.source}"
-                end
+            if value_node.hash_type?
+              pair = find_pair(value_node, Regexp.last_match(2))
+              lhs = pair.value
+              operator = '..'
+            end
+          when LTEQ_NAMED_RE
+            value_node = values_node[0]
+
+            if value_node.hash_type?
+              pair = find_pair(value_node, Regexp.last_match(2))
+              if pair && target_ruby_version >= 2.7
+                operator = range_operator(Regexp.last_match(2))
+                rhs = pair.value
               end
-            when RANGE_NAMED_RE
-              value_node = values_node[0]
-
-              if value_node.hash_type?
-                range_operator = range_operator(Regexp.last_match(3))
-                pair1 = find_pair(value_node, Regexp.last_match(2))
-                pair2 = find_pair(value_node, Regexp.last_match(4))
-                "#{pair1.value.source}#{range_operator}#{pair2.value.source}" if pair1 && pair2
+            end
+          when RANGE_NAMED_RE
+            value_node = values_node[0]
+
+            if value_node.hash_type?
+              pair1 = find_pair(value_node, Regexp.last_match(2))
+              pair2 = find_pair(value_node, Regexp.last_match(4))
+
+              if pair1 && pair2
+                lhs = pair1.value
+                operator = range_operator(Regexp.last_match(3))
+                rhs = pair2.value
               end
             end
+          end
 
-          [Regexp.last_match(1), value] if value
+          if lhs
+            lhs_source = parentheses_needed?(lhs) ? "(#{lhs.source})" : lhs.source
+          end
+
+          if rhs
+            rhs_source = parentheses_needed?(rhs) ? "(#{rhs.source})" : rhs.source
+          end
+
+          [Regexp.last_match(1), "#{lhs_source}#{operator}#{rhs_source}"] if operator
         end
         # rubocop:enable Metrics
 
@@ -151,6 +175,23 @@ module RuboCop
             "#{method_name}(#{column}: #{value})"
           end
         end
+
+        def parentheses_needed?(node)
+          !parentheses_not_needed?(node)
+        end
+
+        def parentheses_not_needed?(node)
+          node.variable? ||
+            node.literal? ||
+            node.reference? ||
+            node.const_type? ||
+            node.begin_type? ||
+            parenthesized_call_node?(node)
+        end
+
+        def parenthesized_call_node?(node)
+          node.call_type? && (node.arguments.empty? || node.parenthesized_call?)
+        end
       end
     end
   end

data/lib/rubocop/cop/rails_cops.rb

@@ -46,6 +46,7 @@ require_relative 'rails/duration_arithmetic'
 require_relative 'rails/dynamic_find_by'
 require_relative 'rails/eager_evaluation_log_message'
 require_relative 'rails/enum_hash'
+require_relative 'rails/enum_syntax'
 require_relative 'rails/enum_uniqueness'
 require_relative 'rails/env_local'
 require_relative 'rails/environment_comparison'

data/lib/rubocop/rails/schema_loader/schema.rb

@@ -178,7 +178,7 @@ module RuboCop
         attr_reader :table_name
 
         def initialize(node)
-          super(node)
+          super
 
           @table_name = node.first_argument.value
           @columns, @expression = build_columns_or_expr(node.arguments[1])

data/lib/rubocop/rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Rails
     # This module holds the RuboCop Rails version information.
     module Version
-      STRING = '2.25.0'
+      STRING = '2.26.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rails
 version: !ruby/object:Gem::Version
-  version: 2.25.0
+  version: 2.26.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-17 00:00:00.000000000 Z
+date: 2024-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -46,7 +46,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.33.0
+        version: 1.52.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -56,7 +56,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.33.0
+        version: 1.52.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '2.0'
@@ -140,6 +140,7 @@ files:
 - lib/rubocop/cop/rails/dynamic_find_by.rb
 - lib/rubocop/cop/rails/eager_evaluation_log_message.rb
 - lib/rubocop/cop/rails/enum_hash.rb
+- lib/rubocop/cop/rails/enum_syntax.rb
 - lib/rubocop/cop/rails/enum_uniqueness.rb
 - lib/rubocop/cop/rails/env_local.rb
 - lib/rubocop/cop/rails/environment_comparison.rb
@@ -246,7 +247,7 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-rails/
   changelog_uri: https://github.com/rubocop/rubocop-rails/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-rails/
-  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.25/
+  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.26/
   bug_tracker_uri: https://github.com/rubocop/rubocop-rails/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -264,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: Automatic Rails code style checking tool.