rubocop-rails 2.25.1 → 2.32.0

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

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def using_squish?(node)
-          node.parent&.send_type? && node.parent&.method?(:squish)
+          node.parent&.send_type? && node.parent.method?(:squish)
         end
 
         def singleline_comments_present?(node)

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def on_send(node)
           return unless (receiver = node.receiver)
-          return unless receiver.str_type? || receiver.dstr_type?
+          return unless receiver.type?(:str, :dstr)
           return unless receiver.respond_to?(:heredoc?) && receiver.heredoc?
 
           register_offense(node, receiver)

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces the use of `ActionController::Parameters#expect` as a method for strong parameter handling.
+      #
+      # @safety
+      #   This cop's autocorrection is considered unsafe because there are cases where the HTTP status may change
+      #   from 500 to 400 when handling invalid parameters. This change, however, reflects an intentional
+      #   incompatibility introduced for valid reasons by the `expect` method, which aligns better with
+      #   strong parameter conventions.
+      #
+      # @example
+      #
+      #   # bad
+      #   params.require(:user).permit(:name, :age)
+      #   params.permit(user: [:name, :age]).require(:user)
+      #
+      #   # good
+      #   params.expect(user: [:name, :age])
+      #
+      class StrongParametersExpect < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[require permit].freeze
+
+        minimum_target_rails_version 8.0
+
+        def_node_matcher :params_require_permit, <<~PATTERN
+          $(call
+            $(call
+              (send nil? :params) :require _) :permit _+)
+        PATTERN
+
+        def_node_matcher :params_permit_require, <<~PATTERN
+          $(call
+            $(call
+               (send nil? :params) :permit (hash (pair _require_param_name _ )))
+                 :require  _require_param_name)
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+
+          if (permit_method, require_method = params_require_permit(node))
+            range = offense_range(require_method, node)
+            prefer = expect_method(require_method, permit_method)
+            replace_argument = true
+          elsif (require_method, permit_method = params_permit_require(node))
+            range = offense_range(permit_method, node)
+            prefer = "expect(#{permit_method.arguments.map(&:source).join(', ')})"
+            replace_argument = false
+          else
+            return
+          end
+
+          add_offense(range, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.remove(require_method.receiver.source_range.end.join(require_method.source_range.end))
+            corrector.replace(permit_method.loc.selector, 'expect')
+            if replace_argument
+              corrector.insert_before(permit_method.first_argument, "#{require_key(require_method)}[")
+              corrector.insert_after(permit_method.last_argument, ']')
+            end
+          end
+
+          ignore_node(node)
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+        alias on_csend on_send
+
+        private
+
+        def offense_range(method_node, node)
+          method_node.loc.selector.join(node.source_range.end)
+        end
+
+        def expect_method(require_method, permit_method)
+          require_key = require_key(require_method)
+          permit_args = permit_method.arguments.map(&:source).join(', ')
+
+          arguments = "#{require_key}[#{permit_args}]"
+
+          "expect(#{arguments})"
+        end
+
+        def require_key(require_method)
+          if (first_argument = require_method.first_argument).respond_to?(:value)
+            require_arg = first_argument.value
+            separator = ': '
+          else
+            require_arg = first_argument.source
+            separator = ' => '
+          end
+
+          "#{require_arg}#{separator}"
+        end
+      end
+    end
+  end
+end

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

@@ -18,8 +18,9 @@ module RuboCop
       #   t.boolean :active, default: true, null: false
       #
       class ThreeStateBooleanColumn < Base
-        MSG = 'Boolean columns should always have a default value and a `NOT NULL` constraint.'
+        include MigrationsHelper
 
+        MSG = 'Boolean columns should always have a default value and a `NOT NULL` constraint.'
         RESTRICT_ON_SEND = %i[add_column column boolean].freeze
 
         def_node_matcher :three_state_boolean?, <<~PATTERN
@@ -44,7 +45,7 @@ module RuboCop
 
             return if required_options?(options_node)
 
-            def_node = node.each_ancestor(:def, :defs).first
+            def_node = node.each_ancestor(:any_def).first
             table_node = table_node(node)
             return if def_node && (table_node.nil? || change_column_null?(def_node, table_node, column_node))
 

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

@@ -28,6 +28,8 @@ module RuboCop
       #   Time.zone.now
       #   Time.zone.parse('2015-03-02T19:05:37')
       #   Time.zone.parse('2015-03-02T19:05:37Z') # Respect ISO 8601 format with timezone specifier.
+      #   Time.parse('2015-03-02T19:05:37Z') # Also respects ISO 8601
+      #   '2015-03-02T19:05:37Z'.to_time # Also respects ISO 8601
       #
       # @example EnforcedStyle: flexible (default)
       #   # `flexible` allows usage of `in_time_zone` instead of `zone`.
@@ -67,6 +69,7 @@ module RuboCop
 
         def on_send(node)
           return if !node.receiver&.str_type? || !node.method?(:to_time)
+          return if attach_timezone_specifier?(node.receiver)
 
           add_offense(node.loc.selector, message: MSG_STRING_TO_TIME) do |corrector|
             corrector.replace(node, "Time.zone.parse(#{node.receiver.source})") unless node.csend_type?
@@ -94,11 +97,9 @@ module RuboCop
         end
 
         def autocorrect_time_new(node, corrector)
-          if node.arguments?
-            corrector.replace(node.loc.selector, 'local')
-          else
-            corrector.replace(node.loc.selector, 'now')
-          end
+          replacement = replacement(node)
+
+          corrector.replace(node.loc.selector, replacement)
         end
 
         # remove redundant `.in_time_zone` from `Time.zone.now.in_time_zone`
@@ -134,7 +135,9 @@ module RuboCop
         end
 
         def attach_timezone_specifier?(date)
-          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s)
+          return false unless date.respond_to?(:value)
+
+          !date.value.to_s.valid_encoding? || TIMEZONE_SPECIFIER.match?(date.value.to_s)
         end
 
         def build_message(klass, method_name, node)
@@ -180,7 +183,7 @@ module RuboCop
 
         def safe_method(method_name, node)
           if %w[new current].include?(method_name)
-            node.arguments? ? 'local' : 'now'
+            replacement(node)
           else
             method_name
           end
@@ -256,6 +259,12 @@ module RuboCop
               pair.key.sym_type? && pair.key.value == :in && !pair.value.nil_type?
             end
         end
+
+        def replacement(node)
+          return 'now' unless node.arguments?
+
+          node.first_argument.str_type? ? 'parse' : 'local'
+        end
       end
     end
   end

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

@@ -15,6 +15,10 @@ module RuboCop
       #
       # If you are defining custom transaction methods, you can configure it with `TransactionMethods`.
       #
+      # NOTE: This cop is disabled on Rails >= 7.2 because transactions were restored
+      # to their historical behavior. In Rails 7.1, the behavior is controlled with
+      # the config `active_record.commit_transaction_on_non_local_return`.
+      #
       # @example
       #   # bad
       #   ApplicationRecord.transaction do
@@ -76,6 +80,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return if target_rails_version >= 7.2
           return unless in_transaction_block?(node)
 
           exit_statements(node.parent.body).each do |statement_node|
@@ -94,7 +99,7 @@ module RuboCop
           return false unless transaction_method_name?(node.method_name)
           return false unless (parent = node.parent)
 
-          parent.block_type? && parent.body
+          parent.any_block_type? && parent.body
         end
 
         def statement(statement_node)
@@ -108,7 +113,7 @@ module RuboCop
         end
 
         def nested_block?(statement_node)
-          name = statement_node.ancestors.find(&:block_type?).children.first.method_name
+          name = statement_node.ancestors.find(&:any_block_type?).children.first.method_name
           !transaction_method_name?(name)
         end
 

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

@@ -51,51 +51,28 @@ module RuboCop
 
         MSG = 'Use `distinct` before `pluck`.'
         RESTRICT_ON_SEND = %i[uniq].freeze
-        NEWLINE = "\n"
-        PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
 
-        def_node_matcher :conservative_node_match, format(PATTERN, type: 'const')
-
-        def_node_matcher :aggressive_node_match, format(PATTERN, type: '_')
+        def_node_matcher :uniq_before_pluck, '[!^any_block $(send $(send _ :pluck ...) :uniq ...)]'
 
         def on_send(node)
-          uniq = if style == :conservative
-                   conservative_node_match(node)
-                 else
-                   aggressive_node_match(node)
-                 end
-
-          return unless uniq
+          uniq_before_pluck(node) do |uniq_node, pluck_node|
+            next if style == :conservative && !pluck_node.receiver&.const_type?
 
-          add_offense(node.loc.selector) do |corrector|
-            autocorrect(corrector, node)
+            add_offense(uniq_node.loc.selector) do |corrector|
+              autocorrect(corrector, uniq_node, pluck_node)
+            end
           end
         end
 
         private
 
-        def autocorrect(corrector, node)
-          method = node.method_name
+        def autocorrect(corrector, uniq_node, pluck_node)
+          corrector.remove(range_between(pluck_node.loc.end.end_pos, uniq_node.loc.selector.end_pos))
 
-          corrector.remove(dot_method_with_whitespace(method, node))
-          if (dot = node.receiver.loc.dot)
+          if (dot = pluck_node.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
-
-        def dot_method_begin_pos(method, node)
-          lines = node.source.split(NEWLINE)
-
-          if lines.last.strip == ".#{method}"
-            node.source.rindex(NEWLINE)
-          else
-            node.loc.dot.begin_pos
+            corrector.insert_before(pluck_node, 'distinct.')
           end
         end
       end

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

@@ -73,7 +73,7 @@ module RuboCop
 
         def column_names(node, uniqueness_part)
           arg = node.first_argument
-          return unless arg.str_type? || arg.sym_type?
+          return unless arg.type?(:str, :sym)
 
           ret = [arg.value]
           names_from_scope = column_names_from_scope(uniqueness_part)

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

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

@@ -89,7 +89,7 @@ module RuboCop
 
         def where_not?(node)
           receiver = node.receiver
-          receiver&.send_type? && receiver&.method?(:where)
+          receiver&.send_type? && receiver.method?(:where)
         end
 
         # rubocop:disable Metrics
@@ -140,6 +140,8 @@ module RuboCop
                 rhs = pair2.value
               end
             end
+          else
+            return
           end
 
           if lhs
@@ -150,7 +152,10 @@ module RuboCop
             rhs_source = parentheses_needed?(rhs) ? "(#{rhs.source})" : rhs.source
           end
 
-          [Regexp.last_match(1), "#{lhs_source}#{operator}#{rhs_source}"] if operator
+          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
 

data/lib/rubocop/cop/rails_cops.rb

@@ -7,9 +7,11 @@ require_relative 'mixin/database_type_resolvable'
 require_relative 'mixin/enforce_superclass'
 require_relative 'mixin/index_method'
 require_relative 'mixin/migrations_helper'
+require_relative 'mixin/routes_helper'
 require_relative 'mixin/target_rails_version'
 
 require_relative 'rails/action_controller_flash_before_render'
+require_relative 'rails/strong_parameters_expect'
 require_relative 'rails/action_controller_test_case'
 require_relative 'rails/action_filter'
 require_relative 'rails/action_order'
@@ -46,6 +48,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'
@@ -76,6 +79,7 @@ require_relative 'rails/link_to_blank'
 require_relative 'rails/mailer_name'
 require_relative 'rails/match_route'
 require_relative 'rails/migration_class_name'
+require_relative 'rails/multiple_route_paths'
 require_relative 'rails/negate_include'
 require_relative 'rails/not_null_column'
 require_relative 'rails/order_by_id'

data/lib/rubocop/rails/migration_file_skippable.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rails
+    # This module allows cops to detect and ignore files that have already been migrated
+    # by leveraging the `AllCops: MigratedSchemaVersion` configuration.
+    #
+    # [source,yaml]
+    # -----
+    # AllCops:
+    #   MigratedSchemaVersion: '20241225000000'
+    # -----
+    #
+    # When applied to cops, it overrides the `add_global_offense` and `add_offense` methods,
+    # ensuring that cops skip processing if the file is determined to be a migrated file
+    # based on the schema version.
+    #
+    # @api private
+    module MigrationFileSkippable
+      def add_global_offense(message = nil, severity: nil)
+        return if already_migrated_file?
+
+        super if method(__method__).super_method
+      end
+
+      def add_offense(node_or_range, message: nil, severity: nil, &block)
+        return if already_migrated_file?
+
+        super if method(__method__).super_method
+      end
+
+      def self.apply_to_cops!
+        RuboCop::Cop::Registry.all.each { |cop| cop.prepend(MigrationFileSkippable) }
+      end
+
+      private
+
+      def already_migrated_file?
+        return false unless migrated_schema_version
+
+        match_data = File.basename(processed_source.file_path).match(/(?<timestamp>\d{14})/)
+        schema_version = match_data['timestamp'] if match_data
+
+        return false unless schema_version
+
+        schema_version <= migrated_schema_version.to_s # Ignore applied migration files.
+      end
+
+      def migrated_schema_version
+        @migrated_schema_version ||= config.for_all_cops.fetch('MigratedSchemaVersion', nil)
+      end
+    end
+  end
+end

data/lib/rubocop/rails/plugin.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Rails
+    # A plugin that integrates RuboCop Rails with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-rails',
+          version: Version::STRING,
+          homepage: 'https://github.com/rubocop/rubocop-rails',
+          description: 'A RuboCop extension focused on enforcing Rails best practices and coding conventions.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        project_root = Pathname.new(__dir__).join('../../..')
+
+        ConfigObsoletion.files << project_root.join('config', 'obsoletion.yml')
+
+        # FIXME: This is a dirty hack relying on a private constant to prevent
+        # "Warning: AllCops does not support TargetRailsVersion parameter".
+        # It should be updated to a better design in the future.
+        without_warnings do
+          ConfigValidator.const_set(:COMMON_PARAMS, ConfigValidator::COMMON_PARAMS.dup << 'TargetRailsVersion')
+        end
+
+        LintRoller::Rules.new(type: :path, config_format: :rubocop, value: project_root.join('config', 'default.yml'))
+      end
+
+      private
+
+      def without_warnings
+        original_verbose = $VERBOSE
+        $VERBOSE = nil
+        yield
+      ensure
+        $VERBOSE = original_verbose
+      end
+    end
+  end
+end

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.1'
+      STRING = '2.32.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/lib/rubocop/rails.rb

@@ -1,14 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  # RuboCop Rails project namespace
+  # RuboCop Rails project namespace.
   module Rails
-    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
-    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read, permitted_classes: [Regexp, Symbol]).freeze
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
-
-    ::RuboCop::ConfigObsoletion.files << PROJECT_ROOT.join('config', 'obsoletion.yml')
   end
 end