rubocop-rails 2.24.1 → 2.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee7d9bdd0fa7838d8bfecece133ccd92cc308603bcdf120c14224c5f2e312344
-  data.tar.gz: 7d740b495ffa368d26a73808af9adff990bb9c1d317d905f877b4f3e2025487c
+  metadata.gz: cad5e6d0c6f188b6ff87adb04fbfb73c7c574b901de45256eb7fa6e50b7a136d
+  data.tar.gz: c8ab8f1d1c3284054af5847231dd996df24ee5441f638f95bc7e32420a3baf04
 SHA512:
-  metadata.gz: 98172f41e7b1aab55931f351757425815850809edd6fc4f5bc55c59271d9f12459ac51c2002e409534b623f321ab27798c32aaccb2d15d60c7bf309a9c044d58
-  data.tar.gz: c78e9a0d9e53e5203a2dd1846a79c3e9c7a16af69e98d94e6b7ae6358ae6a29b71c2ac3f09ddb2a9be06dc64097a736c3379730f50b9309c0e2ae084267aee70
+  metadata.gz: ea0ebe45e988d115aa45d7bdba2b728b0583e1e2d996d43af424eb8abc17ced35b528741fcc47b8b258de52edd2fb7bc1c92dd609b49ddeeaaaf26bce123e783
+  data.tar.gz: 7eb06cfce19f2a4ba78c6d571c65cf386e211b48ca2c9b5b9ca436ec9055e49f9737cbb3f9ce1b44ab432de87121295439effc59f093446cea88199bd08ba8a4

data/config/default.yml

@@ -693,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'
@@ -1163,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
 
@@ -1221,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/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/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/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_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/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.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.1
+  version: 2.25.0
 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-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.