rubocop-rails 2.24.0 → 2.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24df033ffce85b621be414aaec3b62b7b5ac8613e5fc55ce54d58a4be9c22c8b
-  data.tar.gz: 328d994492ff8e6b1f3634e62a1fefaa4e7f3e894492d9f65bc141c7f49e8dac
+  metadata.gz: cad5e6d0c6f188b6ff87adb04fbfb73c7c574b901de45256eb7fa6e50b7a136d
+  data.tar.gz: c8ab8f1d1c3284054af5847231dd996df24ee5441f638f95bc7e32420a3baf04
 SHA512:
-  metadata.gz: 2be5897e47aa2e661a93ece9254578962af30ea0bad2f0303a92f63d846cc37bf7f85d9338e385b29a489202ce762ee5f077dd355443e24695f7b4869f4fd902
-  data.tar.gz: 56db6c7a79ce813778ec0d6fcdbf57de7bdf7ea5b7463c78a58f1919c46b84c3edbbc8f8f02de123439a33df8bdf427b8e29a0d82d51ae624ace0890c8e8158f
+  metadata.gz: ea0ebe45e988d115aa45d7bdba2b728b0583e1e2d996d43af424eb8abc17ced35b528741fcc47b8b258de52edd2fb7bc1c92dd609b49ddeeaaaf26bce123e783
+  data.tar.gz: 7eb06cfce19f2a4ba78c6d571c65cf386e211b48ca2c9b5b9ca436ec9055e49f9737cbb3f9ce1b44ab432de87121295439effc59f093446cea88199bd08ba8a4

data/config/default.yml

@@ -165,6 +165,7 @@ Rails/ActiveSupportOnLoad:
     - 'https://guides.rubyonrails.org/engines.html#available-load-hooks'
   SafeAutoCorrect: false
   VersionAdded: '2.16'
+  VersionChanged: '2.24'
 
 Rails/AddColumnIndex:
   Description: >-
@@ -692,7 +693,7 @@ Rails/NegateInclude:
   VersionChanged: '2.9'
 
 Rails/NotNullColumn:
-  Description: 'Do not add a NOT NULL column without a default value.'
+  Description: 'Do not add a NOT NULL column without a default value to existing tables.'
   Enabled: true
   VersionAdded: '0.43'
   VersionChanged: '2.20'
@@ -1162,8 +1163,9 @@ Rails/UnknownEnv:
 
 Rails/UnusedIgnoredColumns:
   Description: 'Remove a column that does not exist from `ignored_columns`.'
-  Enabled: pending
+  Enabled: false
   VersionAdded: '2.11'
+  VersionChanged: '2.25'
   Include:
     - app/models/**/*.rb
 
@@ -1220,6 +1222,12 @@ Rails/WhereNotWithMultipleConditions:
   VersionAdded: '2.17'
   VersionChanged: '2.18'
 
+Rails/WhereRange:
+  Description: 'Use ranges in `where` instead of manually constructing SQL.'
+  StyleGuide: 'https://rails.rubystyle.guide/#where-ranges'
+  Enabled: pending
+  VersionAdded: '2.25'
+
 # Accept `redirect_to(...) and return` and similar cases.
 Style/AndOr:
   EnforcedStyle: conditionals

data/lib/rubocop/cop/mixin/target_rails_version.rb

@@ -4,13 +4,40 @@ module RuboCop
   module Cop
     # Common functionality for checking target rails version.
     module TargetRailsVersion
+      # Informs the base RuboCop gem that it the Rails version is checked via `requires_gem` API,
+      # without needing to call this `#support_target_rails_version` method.
+      USES_REQUIRES_GEM_API = true
+
       def minimum_target_rails_version(version)
-        @minimum_target_rails_version = version
+        if respond_to?(:requires_gem)
+          case version
+          when Integer, Float then requires_gem(TARGET_GEM_NAME, ">= #{version}")
+          when String then requires_gem(TARGET_GEM_NAME, version)
+          end
+        else
+          # Fallback path for previous versions of RuboCop which don't support the `requires_gem` API yet.
+          @minimum_target_rails_version = version
+        end
       end
 
       def support_target_rails_version?(version)
-        @minimum_target_rails_version <= version
+        if respond_to?(:requires_gem)
+          return false unless gem_requirements
+
+          gem_requirement = gem_requirements[TARGET_GEM_NAME]
+          return true unless gem_requirement # If we have no requirement, then we support all versions
+
+          gem_requirement.satisfied_by?(Gem::Version.new(version))
+        else
+          # Fallback path for previous versions of RuboCop which don't support the `requires_gem` API yet.
+          @minimum_target_rails_version <= version
+        end
       end
+
+      # Look for `railties` instead of `rails`, to support apps that only use a subset of `rails`
+      # See https://github.com/rubocop/rubocop/pull/11289
+      TARGET_GEM_NAME = 'railties'
+      private_constant :TARGET_GEM_NAME
     end
   end
 end

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

@@ -99,6 +99,8 @@ module RuboCop
 
         def use_redirect_to?(context)
           context.right_siblings.compact.any? do |sibling|
+            # Unwrap `return redirect_to :index`
+            sibling = sibling.children.first if sibling.return_type? && sibling.children.one?
             sibling.send_type? && sibling.method?(:redirect_to)
           end
         end

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

@@ -55,15 +55,35 @@ module RuboCop
           'ActiveSupport::TestCase' => 'active_support_test_case'
         }.freeze
 
+        RAILS_5_2_LOAD_HOOKS = {
+          'ActiveRecord::ConnectionAdapters::SQLite3Adapter' => 'active_record_sqlite3adapter'
+        }.freeze
+
+        RAILS_7_1_LOAD_HOOKS = {
+          'ActiveRecord::TestFixtures' => 'active_record_fixtures',
+          'ActiveModel::Model' => 'active_model',
+          'ActionText::EncryptedRichText' => 'action_text_encrypted_rich_text',
+          'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter' => 'active_record_postgresqladapter',
+          'ActiveRecord::ConnectionAdapters::Mysql2Adapter' => 'active_record_mysql2adapter',
+          'ActiveRecord::ConnectionAdapters::TrilogyAdapter' => 'active_record_trilogyadapter'
+        }.freeze
+
         def on_send(node)
           receiver, method, arguments = *node # rubocop:disable InternalAffairs/NodeDestructuring
-          return unless receiver && (hook = LOAD_HOOKS[receiver.const_name])
+          return unless arguments && (hook = hook_for_const(receiver&.const_name))
 
           preferred = "ActiveSupport.on_load(:#{hook}) { #{method} #{arguments.source} }"
           add_offense(node, message: format(MSG, prefer: preferred, current: node.source)) do |corrector|
             corrector.replace(node, preferred)
           end
         end
+
+        def hook_for_const(const_name)
+          hook = LOAD_HOOKS[const_name]
+          hook ||= RAILS_5_2_LOAD_HOOKS[const_name] if target_rails_version >= 5.2
+          hook ||= RAILS_7_1_LOAD_HOOKS[const_name] if target_rails_version >= 7.1
+          hook
+        end
       end
     end
   end

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

@@ -51,7 +51,7 @@ module RuboCop
           return if allow?(begin_node, end_node)
 
           preferred_method = preferred_method(begin_node)
-          if begin_node.method?(:beginning_of_week) && begin_node.arguments.one?
+          if begin_node.method?(:beginning_of_week) && begin_node.arguments.one? && end_node.arguments.one?
             return unless same_argument?(begin_node, end_node)
 
             preferred_method << "(#{begin_node.first_argument.source})"

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

@@ -13,6 +13,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #   head 200
+      #   assert_response 200
+      #   assert_redirected_to '/some/path', status: 301
       #
       #   # good
       #   render :foo, status: :ok
@@ -20,6 +22,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #   head :ok
+      #   assert_response :ok
+      #   assert_redirected_to '/some/path', status: :moved_permanently
       #
       # @example EnforcedStyle: numeric
       #   # bad
@@ -28,6 +32,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #   head :ok
+      #   assert_response :ok
+      #   assert_redirected_to '/some/path', status: :moved_permanently
       #
       #   # good
       #   render :foo, status: 200
@@ -35,18 +41,22 @@ module RuboCop
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #   head 200
+      #   assert_response 200
+      #   assert_redirected_to '/some/path', status: 301
       #
       class HttpStatus < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
+        RESTRICT_ON_SEND = %i[render redirect_to head assert_response assert_redirected_to].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
             (send nil? {:render :redirect_to} _ $hash)
             (send nil? {:render :redirect_to} $hash)
-            (send nil? :head ${int sym} ...)
+            (send nil? {:head :assert_response} ${int sym} ...)
+            (send nil? :assert_redirected_to _ $hash ...)
+            (send nil? :assert_redirected_to $hash ...)
           }
         PATTERN
 

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

@@ -3,24 +3,42 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks for add_column call with NOT NULL constraint in migration file.
+      # Checks for add_column calls with a NOT NULL constraint without a default
+      # value.
       #
-      # `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`.
+      # This cop only applies when adding a column to an existing table, since
+      # existing records will not have a value for the new column. New tables
+      # can freely use NOT NULL columns without defaults, since there are no
+      # records that could violate the constraint.
+      #
+      # If you need to add a NOT NULL column to an existing table, you must add
+      # it as nullable first, back-fill the data, and then use
+      # `change_column_null`. Alternatively, you could add the column with a
+      # default first to have the database automatically backfill existing rows,
+      # and then use `change_column_default` to remove the default.
+      #
+      # `TEXT` cannot have a default value in MySQL.
+      # The cop 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 `TEXT` columns.
       #
       # @example
       #   # bad
       #   add_column :users, :name, :string, null: false
       #   add_reference :products, :category, null: false
+      #   change_table :users do |t|
+      #     t.string :name, null: false
+      #   end
       #
       #   # good
       #   add_column :users, :name, :string, null: true
       #   add_column :users, :name, :string, null: false, default: ''
+      #   change_table :users do |t|
+      #     t.string :name, null: false, default: ''
+      #   end
       #   add_reference :products, :category
-      #   add_reference :products, :category, null: false, default: 1
+      #   change_column_null :products, :category_id, false
       class NotNullColumn < Base
         include DatabaseTypeResolvable
 
@@ -35,6 +53,22 @@ module RuboCop
           (send nil? :add_reference _ _ (hash $...))
         PATTERN
 
+        def_node_matcher :change_table?, <<~PATTERN
+          (block (send nil? :change_table ...) (args (arg $_)) _)
+        PATTERN
+
+        def_node_matcher :add_not_null_column_in_change_table?, <<~PATTERN
+          (send (lvar $_) :column _ $_ (hash $...))
+        PATTERN
+
+        def_node_matcher :add_not_null_column_via_shortcut_in_change_table?, <<~PATTERN
+          (send (lvar $_) $_ _ (hash $...))
+        PATTERN
+
+        def_node_matcher :add_not_null_reference_in_change_table?, <<~PATTERN
+          (send (lvar $_) :add_reference _ _ (hash $...))
+        PATTERN
+
         def_node_matcher :null_false?, <<~PATTERN
           (pair (sym :null) (false))
         PATTERN
@@ -48,16 +82,25 @@ module RuboCop
           check_add_reference(node)
         end
 
+        def on_block(node)
+          check_change_table(node)
+        end
+        alias on_numblock on_block
+
         private
 
+        def check_column(type, pairs)
+          if type.respond_to?(:value)
+            return if type.value == :virtual || type.value == 'virtual'
+            return if (type.value == :text || type.value == 'text') && database == MYSQL
+          end
+
+          check_pairs(pairs)
+        end
+
         def check_add_column(node)
           add_not_null_column?(node) do |type, pairs|
-            if type.respond_to?(:value)
-              return if type.value == :virtual || type.value == 'virtual'
-              return if (type.value == :text || type.value == 'text') && database == MYSQL
-            end
-
-            check_pairs(pairs)
+            check_column(type, pairs)
           end
         end
 
@@ -67,6 +110,41 @@ module RuboCop
           end
         end
 
+        def check_add_column_in_change_table(node, table)
+          add_not_null_column_in_change_table?(node) do |receiver, type, pairs|
+            next unless receiver == table
+
+            check_column(type, pairs)
+          end
+        end
+
+        def check_add_column_via_shortcut_in_change_table(node, table)
+          add_not_null_column_via_shortcut_in_change_table?(node) do |receiver, type, pairs|
+            next unless receiver == table
+
+            check_column(type, pairs)
+          end
+        end
+
+        def check_add_reference_in_change_table(node, table)
+          add_not_null_reference_in_change_table?(node) do |receiver, pairs|
+            next unless receiver == table
+
+            check_pairs(pairs)
+          end
+        end
+
+        def check_change_table(node)
+          change_table?(node) do |table|
+            children = node.body.begin_type? ? node.body.children : [node.body]
+            children.each do |child|
+              check_add_column_in_change_table(child, table)
+              check_add_column_via_shortcut_in_change_table(child, table)
+              check_add_reference_in_change_table(child, table)
+            end
+          end
+        end
+
         def check_pairs(pairs)
           return if pairs.any? { |pair| default_option?(pair) }
 

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

@@ -9,6 +9,10 @@ module RuboCop
       # `pick` avoids. When called on an Active Record relation, `pick` adds a
       # limit to the query so that only one value is fetched from the database.
       #
+      # Note that when `pick` is added to a relation with an existing limit, it
+      # causes a subquery to be added. In most cases this is undesirable, and
+      # care should be taken while resolving this violation.
+      #
       # @safety
       #   This cop is unsafe because `pluck` is defined on both `ActiveRecord::Relation` and `Enumerable`,
       #   whereas `pick` is only defined on `ActiveRecord::Relation` in Rails 6.0. This was addressed

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

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

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

@@ -63,7 +63,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :good_insert?, <<~PATTERN
-          (send _ {:insert :insert!} _ {
+          (call _ {:insert :insert!} _ {
             !(hash ...)
             (hash <(pair (sym !{:returning :unique_by}) _) ...>)
           } ...)

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

@@ -69,9 +69,10 @@ module RuboCop
           return if !node.receiver&.str_type? || !node.method?(:to_time)
 
           add_offense(node.loc.selector, message: MSG_STRING_TO_TIME) do |corrector|
-            corrector.replace(node, "Time.zone.parse(#{node.receiver.source})")
+            corrector.replace(node, "Time.zone.parse(#{node.receiver.source})") unless node.csend_type?
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -68,15 +68,23 @@ module RuboCop
           return unless uniq
 
           add_offense(node.loc.selector) do |corrector|
-            method = node.method_name
-
-            corrector.remove(dot_method_with_whitespace(method, node))
-            corrector.insert_before(node.receiver.loc.dot.begin, '.distinct')
+            autocorrect(corrector, node)
           end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          method = node.method_name
+
+          corrector.remove(dot_method_with_whitespace(method, node))
+          if (dot = node.receiver.loc.dot)
+            corrector.insert_before(dot.begin, '.distinct')
+          else
+            corrector.insert_before(node.receiver, 'distinct.')
+          end
+        end
+
         def dot_method_with_whitespace(method, node)
           range_between(dot_method_begin_pos(method, node), node.loc.selector.end_pos)
         end

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

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

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

@@ -7,6 +7,12 @@ module RuboCop
       # `ignored_columns` is necessary to drop a column from RDBMS, but you don't need it after the migration
       # to drop the column. You avoid forgetting to remove `ignored_columns` by this cop.
       #
+      # IMPORTANT: This cop can't be used to effectively check for unused columns because the development
+      # and production schema can be out of sync until the migration has been run on production. As such,
+      # this cop can cause `ignored_columns` to be removed even though the production schema still contains
+      # the column, which can lead to downtime when the migration is actually executed. Only enable this cop
+      # if you know your migrations will be run before any of your Rails applications boot with the modified code.
+      #
       # @example
       #   # bad
       #   class User < ApplicationRecord

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

@@ -29,7 +29,7 @@ module RuboCop
       #   validates :foo, numericality: true
       #   validates :foo, presence: true
       #   validates :foo, absence: true
-      #   validates :foo, size: true
+      #   validates :foo, length: true
       #   validates :foo, uniqueness: true
       #
       class Validation < Base
@@ -120,7 +120,9 @@ module RuboCop
         end
 
         def validate_type(node)
-          node.method_name.to_s.split('_')[1]
+          type = node.method_name.to_s.split('_')[1]
+
+          type == 'size' ? 'length' : type
         end
 
         def frozen_array_argument?(argument)

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

@@ -89,16 +89,20 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def remove_where_method(corrector, node, where_node)
           range = range_between(where_node.loc.selector.begin_pos, where_node.loc.end.end_pos)
           if node.multiline? && !same_line?(node, where_node)
             range = range_by_whole_lines(range, include_final_newline: true)
-          else
+          elsif where_node.receiver
             corrector.remove(where_node.loc.dot)
+          else
+            corrector.remove(node.loc.dot)
           end
 
           corrector.remove(range)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def same_line?(left_joins_node, where_node)
           left_joins_node.loc.selector.line == where_node.loc.selector.line

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies places where manually constructed SQL
+      # in `where` can be replaced with ranges.
+      #
+      # @example
+      #   # bad
+      #   User.where('age >= ?', 18)
+      #   User.where.not('age >= ?', 18)
+      #   User.where('age < ?', 18)
+      #   User.where('age >= ? AND age < ?', 18, 21)
+      #   User.where('age >= :start', start: 18)
+      #   User.where('users.age >= ?', 18)
+      #
+      #   # good
+      #   User.where(age: 18..)
+      #   User.where.not(age: 18..)
+      #   User.where(age: ...18)
+      #   User.where(age: 18...21)
+      #   User.where(users: { age: 18.. })
+      #
+      #   # good
+      #   # There are no beginless ranges in ruby.
+      #   User.where('age > ?', 18)
+      #
+      class WhereRange < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<good_method>s` instead of manually constructing SQL.'
+
+        RESTRICT_ON_SEND = %i[where not].freeze
+
+        # column >= ?
+        GTEQ_ANONYMOUS_RE   = /\A([\w.]+)\s+>=\s+\?\z/.freeze
+        # column <[=] ?
+        LTEQ_ANONYMOUS_RE   = /\A([\w.]+)\s+(<=?)\s+\?\z/.freeze
+        # column >= ? AND column <[=] ?
+        RANGE_ANONYMOUS_RE  = /\A([\w.]+)\s+>=\s+\?\s+AND\s+\1\s+(<=?)\s+\?\z/i.freeze
+        # column >= :value
+        GTEQ_NAMED_RE       = /\A([\w.]+)\s+>=\s+:(\w+)\z/.freeze
+        # column <[=] :value
+        LTEQ_NAMED_RE       = /\A([\w.]+)\s+(<=?)\s+:(\w+)\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
+
+        minimum_target_ruby_version 2.6
+        minimum_target_rails_version 6.0
+
+        def_node_matcher :where_range_call?, <<~PATTERN
+          {
+            (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_range_call?(node) do |template_node, values_node|
+            column, value = extract_column_and_value(template_node, values_node)
+
+            return unless column
+
+            range = offense_range(node)
+            good_method = build_good_method(node.method_name, column, value)
+            message = format(MSG, good_method: good_method)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, good_method)
+            end
+          end
+        end
+
+        private
+
+        def where_not?(node)
+          receiver = node.receiver
+          receiver&.send_type? && receiver&.method?(:where)
+        end
+
+        # 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]
+
+              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
+              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
+            end
+
+          [Regexp.last_match(1), value] if value
+        end
+        # rubocop:enable Metrics
+
+        def range_operator(comparison_operator)
+          comparison_operator == '<' ? '...' : '..'
+        end
+
+        def find_pair(hash_node, value)
+          hash_node.pairs.find { |pair| pair.key.value.to_sym == value.to_sym }
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+
+        def build_good_method(method_name, column, value)
+          if column.include?('.')
+            table, column = column.split('.')
+
+            "#{method_name}(#{table}: { #{column}: #{value} })"
+          else
+            "#{method_name}(#{column}: #{value})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -138,3 +138,4 @@ require_relative 'rails/where_exists'
 require_relative 'rails/where_missing'
 require_relative 'rails/where_not'
 require_relative 'rails/where_not_with_multiple_conditions'
+require_relative 'rails/where_range'

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

@@ -30,6 +30,7 @@ module RuboCop
 
         def build!(ast)
           raise "Unexpected type: #{ast.type}" unless ast.block_type?
+          return unless ast.body
 
           each_table(ast) do |table_def|
             next unless table_def.method?(:create_table)

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.24.0'
+      STRING = '2.25.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.24.0
+  version: 2.25.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-03 00:00:00.000000000 Z
+date: 2024-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -232,6 +232,7 @@ files:
 - lib/rubocop/cop/rails/where_missing.rb
 - lib/rubocop/cop/rails/where_not.rb
 - lib/rubocop/cop/rails/where_not_with_multiple_conditions.rb
+- lib/rubocop/cop/rails/where_range.rb
 - lib/rubocop/cop/rails_cops.rb
 - lib/rubocop/rails.rb
 - lib/rubocop/rails/inject.rb
@@ -245,7 +246,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.24/
+  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.25/
   bug_tracker_uri: https://github.com/rubocop/rubocop-rails/issues
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -263,7 +264,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Automatic Rails code style checking tool.