rubocop-rails 2.24.1 → 2.26.2

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|
@@ -69,11 +74,12 @@ module RuboCop
           range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def extract_column_and_value(template_node, value_node)
           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?
 
@@ -85,18 +91,28 @@ module RuboCop
               return
             end
 
-          [Regexp.last_match(1), value]
+          column_qualifier = Regexp.last_match(1)
+          return if column_qualifier.count('.') > 1
+
+          [column_qualifier, value]
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
-        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|
@@ -68,13 +68,14 @@ module RuboCop
           range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def extract_column_and_value(template_node, value_node)
           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
@@ -84,8 +85,12 @@ module RuboCop
               return
             end
 
-          [Regexp.last_match(1), value]
+          column_qualifier = Regexp.last_match(1)
+          return if column_qualifier.count('.') > 1
+
+          [column_qualifier, value]
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
         def build_good_method(dot, column, value)
           dot ||= '.'

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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)
+      #   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\s*([\w.]+)\s+>=\s+\?\s*\z/.freeze
+        # column <[=] ?
+        LTEQ_ANONYMOUS_RE   = /\A\s*([\w.]+)\s+(<=?)\s+\?\s*\z/.freeze
+        # column >= ? AND column <[=] ?
+        RANGE_ANONYMOUS_RE  = /\A\s*([\w.]+)\s+>=\s+\?\s+AND\s+\1\s+(<=?)\s+\?\s*\z/i.freeze
+        # column >= :value
+        GTEQ_NAMED_RE       = /\A\s*([\w.]+)\s+>=\s+:(\w+)\s*\z/.freeze
+        # column <[=] :value
+        LTEQ_NAMED_RE       = /\A\s*([\w.]+)\s+(<=?)\s+:(\w+)\s*\z/.freeze
+        # column >= :value1 AND column <[=] :value2
+        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
+
+        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)
+          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))
+              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
+            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
+          else
+            return
+          end
+
+          if lhs
+            lhs_source = parentheses_needed?(lhs) ? "(#{lhs.source})" : lhs.source
+          end
+
+          if rhs
+            rhs_source = parentheses_needed?(rhs) ? "(#{rhs.source})" : rhs.source
+          end
+
+          column_qualifier = Regexp.last_match(1)
+          return if column_qualifier.count('.') > 1
+
+          [column_qualifier, "#{lhs_source}#{operator}#{rhs_source}"] if operator
+        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
+
+        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
+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'
@@ -138,3 +139,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

@@ -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.24.1'
+      STRING = '2.26.2'
 
       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.1
+  version: 2.26.2
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-25 00:00:00.000000000 Z
+date: 2024-09-21 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
@@ -232,6 +233,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 +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.24/
+  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:
@@ -263,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Automatic Rails code style checking tool.