rubocop-rails 2.11.2 → 2.19.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of `Time.zone=` method.
+      # Checks for the use of `Time.zone=` method.
       #
       # The `zone` attribute persists for the rest of the Ruby runtime, potentially causing
       # unexpected behavior at a later time.
@@ -22,12 +22,12 @@ module RuboCop
         MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
         RESTRICT_ON_SEND = %i[zone=].freeze
 
-        def_node_matcher :time_zone_assignement?, <<~PATTERN
-          (send (const nil? :Time) :zone= ...)
+        def_node_matcher :time_zone_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :Time) :zone= ...)
         PATTERN
 
         def on_send(node)
-          return unless time_zone_assignement?(node)
+          return unless time_zone_assignment?(node)
 
           add_offense(node)
         end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for consistent uses of `to_fs` or `to_formatted_s`,
+      # depending on the cop's configuration.
+      #
+      # @example EnforcedStyle: to_fs (default)
+      #
+      #   # bad
+      #   time.to_formatted_s(:db)
+      #
+      #   # good
+      #   time.to_fs(:db)
+      #
+      # @example EnforcedStyle: to_formatted_s
+      #
+      #   # bad
+      #   time.to_fs(:db)
+      #
+      #   # good
+      #   time.to_formatted_s(:db)
+      #
+      class ToFormattedS < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 7.0
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[to_formatted_s to_fs].freeze
+
+        def on_send(node)
+          return if node.method?(style)
+
+          add_offense(node.loc.selector, message: format(MSG, prefer: style)) do |corrector|
+            corrector.replace(node.loc.selector, style)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies passing any argument to `#to_s`.
+      #
+      # @safety
+      #   This cop is marked as unsafe because it may detect `#to_s` calls
+      #   that are not related to Active Support implementation.
+      #
+      # @example
+      #
+      #   # bad
+      #   obj.to_s(:delimited)
+      #
+      #   # good
+      #   obj.to_formatted_s(:delimited)
+      #
+      class ToSWithArgument < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        # These types are defined by the following files in ActiveSupport:
+        #   lib/active_support/core_ext/array/conversions.rb
+        #   lib/active_support/core_ext/date/conversions.rb
+        #   lib/active_support/core_ext/date_time/conversions.rb
+        #   lib/active_support/core_ext/numeric/conversions.rb
+        #   lib/active_support/core_ext/range/conversions.rb
+        #   lib/active_support/core_ext/time/conversions.rb
+        #   lib/active_support/time_with_zone.rb
+        EXTENDED_FORMAT_TYPES = Set.new(
+          %i[
+            currency
+            db
+            delimited
+            human
+            human_size
+            inspect
+            iso8601
+            long
+            long_ordinal
+            nsec
+            number
+            percentage
+            phone
+            rfc822
+            rounded
+            short
+            time
+            usec
+          ]
+        )
+
+        MSG = 'Use `to_formatted_s` instead.'
+
+        RESTRICT_ON_SEND = %i[to_s].freeze
+
+        minimum_target_rails_version 7.0
+
+        def on_send(node)
+          return unless rails_extended_to_s?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'to_formatted_s')
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def rails_extended_to_s?(node)
+          node.first_argument&.sym_type? && EXTENDED_FORMAT_TYPES.include?(node.first_argument.value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies top-level `HashWithIndifferentAccess`.
+      # This has been soft-deprecated since Rails 5.1.
+      #
+      # @example
+      #   # bad
+      #   HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      #   # good
+      #   ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      class TopLevelHashWithIndifferentAccess < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.1
+
+        MSG = 'Avoid top-level `HashWithIndifferentAccess`.'
+
+        # @!method top_level_hash_with_indifferent_access?(node)
+        #   @param [RuboCop::AST::ConstNode] node
+        #   @return [Boolean]
+        def_node_matcher :top_level_hash_with_indifferent_access?, <<~PATTERN
+          (const {nil? cbase} :HashWithIndifferentAccess)
+        PATTERN
+
+        # @param [RuboCop::AST::ConstNode] node
+        def on_const(node)
+          return unless top_level_hash_with_indifferent_access?(node)
+          return if node.parent&.class_type? && node.parent.ancestors.any?(&:module_type?)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.insert_before(node.location.name, 'ActiveSupport::')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for the use of exit statements (namely `return`,
+      # `break` and `throw`) in transactions. This is due to the eventual
+      # unexpected behavior when using ActiveRecord >= 7, where transactions
+      # exited using these statements are being rollbacked rather than
+      # committed (pre ActiveRecord 7 behavior).
+      #
+      # As alternatives, it would be more intuitive to explicitly raise an
+      # error when rollback is desired, and to use `next` when commit is
+      # desired.
+      #
+      # @example
+      #   # bad
+      #   ApplicationRecord.transaction do
+      #     return if user.active?
+      #   end
+      #
+      #   # bad
+      #   ApplicationRecord.transaction do
+      #     break if user.active?
+      #   end
+      #
+      #   # bad
+      #   ApplicationRecord.transaction do
+      #     throw if user.active?
+      #   end
+      #
+      #   # bad, as `with_lock` implicitly opens a transaction too
+      #   user.with_lock do
+      #     throw if user.active?
+      #   end
+      #
+      #   # good
+      #   ApplicationRecord.transaction do
+      #     # Rollback
+      #     raise "User is active" if user.active?
+      #   end
+      #
+      #   # good
+      #   ApplicationRecord.transaction do
+      #     # Commit
+      #     next if user.active?
+      #   end
+      class TransactionExitStatement < Base
+        MSG = <<~MSG.chomp
+          Exit statement `%<statement>s` is not allowed. Use `raise` (rollback) or `next` (commit).
+        MSG
+
+        RESTRICT_ON_SEND = %i[transaction with_lock].freeze
+
+        def_node_search :exit_statements, <<~PATTERN
+          ({return | break | send nil? :throw} ...)
+        PATTERN
+
+        def_node_matcher :rescue_body_return_node?, <<~PATTERN
+          (:resbody ...
+            ...
+            ({return | break | send nil? :throw} ...)
+            ...
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless (parent = node.parent)
+          return unless parent.block_type? && parent.body
+
+          exit_statements(parent.body).each do |statement_node|
+            next if statement_node.break_type? && nested_block?(statement_node)
+
+            statement = statement(statement_node)
+            message = format(MSG, statement: statement)
+
+            add_offense(statement_node, message: message)
+          end
+        end
+
+        private
+
+        def statement(statement_node)
+          if statement_node.return_type?
+            'return'
+          elsif statement_node.break_type?
+            'break'
+          else
+            statement_node.method_name
+          end
+        end
+
+        def nested_block?(statement_node)
+          !statement_node.ancestors.find(&:block_type?).method?(:transaction)
+        end
+      end
+    end
+  end
+end

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

@@ -3,47 +3,46 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer the use of distinct, before pluck instead of after.
+      # Prefer using `distinct` before `pluck` instead of `uniq` after `pluck`.
       #
-      # The use of distinct before pluck is preferred because it executes within
+      # The use of distinct before pluck is preferred because it executes by
       # the database.
       #
       # 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) before distinct are added as offenses.
+      # is `conservative` (the default), then only calls to `pluck` on a constant
+      # (i.e. a model class) before `uniq` are added as offenses.
       #
-      # When the EnforcedStyle is aggressive then all calls to pluck before
+      # When the EnforcedStyle is `aggressive` then all calls to `pluck` before
       # distinct are added as offenses. This may lead to false positives
-      # as the cop cannot distinguish between calls to pluck on an
+      # as the cop cannot distinguish between calls to `pluck` on an
       # ActiveRecord::Relation vs a call to pluck on an
       # ActiveRecord::Associations::CollectionProxy.
       #
-      # This cop is unsafe because the behavior may change depending on the
-      # database collation.
-      # Autocorrect is disabled by default for this cop since it may generate
-      # false positives.
+      # @safety
+      #   This cop is unsafe for autocorrection because the behavior may change
+      #   depending on the database collation.
       #
       # @example EnforcedStyle: conservative (default)
-      #   # bad
-      #   Model.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.pluck(:band_name).uniq
       #
       #   # good
-      #   Model.distinct.pluck(:id)
+      #   Album.distinct.pluck(:band_name)
       #
       # @example EnforcedStyle: aggressive
-      #   # bad
-      #   # this will return a Relation that pluck is called on
-      #   Model.where(cond: true).pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.pluck(:band_name).uniq
       #
-      #   # bad
-      #   # an association on an instance will return a CollectionProxy
-      #   instance.assoc.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.where(year: 1985).pluck(:band_name).uniq
       #
-      #   # bad
-      #   Model.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   customer.favourites.pluck(:color).uniq
       #
       #   # good
-      #   Model.distinct.pluck(:id)
+      #   Album.distinct.pluck(:band_name)
+      #   Album.distinct.where(year: 1985).pluck(:band_name)
+      #   customer.favourites.distinct.pluck(:color)
       #
       class UniqBeforePluck < Base
         include ConfigurableEnforcedStyle
@@ -51,25 +50,22 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `distinct` before `pluck`.'
-        RESTRICT_ON_SEND = %i[uniq distinct pluck].freeze
+        RESTRICT_ON_SEND = %i[uniq].freeze
         NEWLINE = "\n"
-        PATTERN = '[!^block (send (send %<type>s :pluck ...) ' \
-                  '${:uniq :distinct} ...)]'
+        PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
 
-        def_node_matcher :conservative_node_match,
-                         format(PATTERN, type: 'const')
+        def_node_matcher :conservative_node_match, format(PATTERN, type: 'const')
 
-        def_node_matcher :aggressive_node_match,
-                         format(PATTERN, type: '_')
+        def_node_matcher :aggressive_node_match, format(PATTERN, type: '_')
 
         def on_send(node)
-          method = if style == :conservative
-                     conservative_node_match(node)
-                   else
-                     aggressive_node_match(node)
-                   end
+          uniq = if style == :conservative
+                   conservative_node_match(node)
+                 else
+                   aggressive_node_match(node)
+                 end
 
-          return unless method
+          return unless uniq
 
           add_offense(node.loc.selector) do |corrector|
             method = node.method_name
@@ -81,13 +77,8 @@ module RuboCop
 
         private
 
-        def style_parameter_name
-          'EnforcedStyle'
-        end
-
         def dot_method_with_whitespace(method, node)
-          range_between(dot_method_begin_pos(method, node),
-                        node.loc.selector.end_pos)
+          range_between(dot_method_begin_pos(method, node), node.loc.selector.end_pos)
         end
 
         def dot_method_begin_pos(method, node)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Rails
       # When you define a uniqueness validation in Active Record model,
-      # you also should add a unique index for the column. There are two reasons
+      # you also should add a unique index for the column. There are two reasons.
       # First, duplicated records may occur even if Active Record's validation
       # is defined.
       # Second, it will cause slow queries. The validation executes a `SELECT`
@@ -27,7 +27,7 @@ module RuboCop
       class UniqueValidationWithoutIndex < Base
         include ActiveRecordHelper
 
-        MSG = 'Uniqueness validation should be with a unique index.'
+        MSG = 'Uniqueness validation should have a unique index on the database column.'
         RESTRICT_ON_SEND = %i[validates].freeze
 
         def on_send(node)
@@ -56,12 +56,10 @@ module RuboCop
 
         def with_index?(klass, table, names)
           # Compatibility for Rails 4.2.
-          add_indicies = schema.add_indicies_by(table_name: table_name(klass))
+          add_indices = schema.add_indices_by(table_name: table_name(klass))
 
-          (table.indices + add_indicies).any? do |index|
-            index.unique &&
-              (index.columns.to_set == names ||
-               include_column_names_in_expression_index?(index, names))
+          (table.indices + add_indices).any? do |index|
+            index.unique && (index.columns.to_set == names || include_column_names_in_expression_index?(index, names))
           end
         end
 
@@ -81,7 +79,7 @@ module RuboCop
           names_from_scope = column_names_from_scope(node)
           ret.concat(names_from_scope) if names_from_scope
 
-          ret.map! do |name|
+          ret = ret.flat_map do |name|
             klass = class_node(node)
             resolve_relation_into_column(
               name: name.to_s,
@@ -141,11 +139,20 @@ module RuboCop
           pairs = node.arguments.last
           return unless pairs.hash_type?
 
+          return true if condition_hash_part?(pairs, keys: %i[if unless])
+
+          uniqueness_node = uniqueness_part(node)
+          return unless uniqueness_node&.hash_type?
+
+          condition_hash_part?(uniqueness_node, keys: %i[if unless conditions])
+        end
+
+        def condition_hash_part?(pairs, keys:)
           pairs.each_pair.any? do |pair|
             key = pair.key
             next unless key.sym_type?
 
-            key.value == :if || key.value == :unless
+            keys.include?(key.value)
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that environments called with `Rails.env` predicates
+      # Checks that environments called with `Rails.env` predicates
       # exist.
       # By default the cop allows three environments which Rails ships with:
       # `development`, `test`, and `production`.
@@ -19,8 +19,7 @@ module RuboCop
       #   Rails.env == 'production'
       class UnknownEnv < Base
         MSG = 'Unknown environment `%<name>s`.'
-        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
-                      'Did you mean `%<similar>s`?'
+        MSG_SIMILAR = 'Unknown environment `%<name>s`. Did you mean `%<similar>s`?'
 
         def_node_matcher :rails_env?, <<~PATTERN
           (send
@@ -79,8 +78,7 @@ module RuboCop
 
         def unknown_env_predicate?(name)
           name = name.to_s
-          name.end_with?('?') &&
-            !environments.include?(name[0..-2])
+          name.end_with?('?') && !environments.include?(name[0..-2])
         end
 
         def unknown_env_name?(name)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop suggests you remove a column that does not exist in the schema from `ignored_columns`.
+      # Suggests you remove a column that does not exist in the schema from `ignored_columns`.
       # `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.
       #
@@ -28,12 +28,16 @@ module RuboCop
           (send self :ignored_columns= $array)
         PATTERN
 
+        def_node_matcher :appended_ignored_columns, <<~PATTERN
+          (op-asgn (send self :ignored_columns) :+ $array)
+        PATTERN
+
         def_node_matcher :column_name, <<~PATTERN
           ({str sym} $_)
         PATTERN
 
         def on_send(node)
-          return unless (columns = ignored_columns(node))
+          return unless (columns = ignored_columns(node) || appended_ignored_columns(node))
           return unless schema
 
           table = table(node)
@@ -43,6 +47,7 @@ module RuboCop
             check_column_existence(column_node, table)
           end
         end
+        alias on_op_asgn on_send
 
         private
 
@@ -61,6 +66,8 @@ module RuboCop
 
         def table(node)
           klass = class_node(node)
+          return unless klass
+
           schema.table_by(name: table_name(klass))
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of old-style attribute validation macros.
+      # Checks for the use of old-style attribute validation macros.
       #
       # @example
       #   # bad
@@ -35,8 +35,7 @@ module RuboCop
       class Validation < Base
         extend AutoCorrector
 
-        MSG = 'Prefer the new style validations `%<prefer>s` over ' \
-              '`%<current>s`.'
+        MSG = 'Prefer the new style validations `%<prefer>s` over `%<current>s`.'
 
         TYPES = %w[
           acceptance
@@ -62,8 +61,7 @@ module RuboCop
 
           add_offense(range, message: message(node)) do |corrector|
             last_argument = node.arguments.last
-            return if !last_argument.literal? && !last_argument.splat_type? &&
-                      !frozen_array_argument?(last_argument)
+            return if !last_argument.literal? && !last_argument.splat_type? && !frozen_array_argument?(last_argument)
 
             corrector.replace(range, 'validates')
             correct_validate_type(corrector, node)
@@ -104,10 +102,7 @@ module RuboCop
         end
 
         def correct_validate_type_for_hash(corrector, node, arguments)
-          corrector.replace(
-            arguments.loc.expression,
-            "#{validate_type(node)}: #{braced_options(arguments)}"
-          )
+          corrector.replace(arguments, "#{validate_type(node)}: #{braced_options(arguments)}")
         end
 
         def correct_validate_type_for_array(corrector, node, arguments, loc)
@@ -121,10 +116,7 @@ module RuboCop
                           end
           end
 
-          corrector.replace(
-            loc.expression,
-            "#{attributes.join(', ')}, #{validate_type(node)}: true"
-          )
+          corrector.replace(loc.expression, "#{attributes.join(', ')}, #{validate_type(node)}: true")
         end
 
         def validate_type(node)

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop identifies places where manually constructed SQL
+      # Identifies places where manually constructed SQL
       # in `where` can be replaced with `where(attribute: value)`.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because is may change SQL.
+      #   See: https://github.com/rubocop/rubocop-rails/issues/403
+      #
       # @example
       #   # bad
       #   User.where('name = ?', 'Gabe')
@@ -61,7 +65,7 @@ module RuboCop
         private
 
         def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def extract_column_and_value(template_node, value_node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces consistent style when using `exists?`.
+      # Enforces consistent style when using `exists?`.
       #
       # Two styles are supported for this cop. When EnforcedStyle is 'exists'
       # then the cop enforces `exists?(...)` over `where(...).exists?`.
@@ -11,16 +11,17 @@ module RuboCop
       # When EnforcedStyle is 'where' then the cop enforces
       # `where(...).exists?` over `exists?(...)`.
       #
-      # This cop is unsafe for auto-correction because the behavior may change on the following case:
+      # @safety
+      #   This cop is unsafe for autocorrection because the behavior may change on the following case:
       #
-      # [source,ruby]
-      # ----
-      # Author.includes(:articles).where(articles: {id: id}).exists?
-      # #=> Perform `eager_load` behavior (`LEFT JOIN` query) and get result.
+      #   [source,ruby]
+      #   ----
+      #   Author.includes(:articles).where(articles: {id: id}).exists?
+      #   #=> Perform `eager_load` behavior (`LEFT JOIN` query) and get result.
       #
-      # Author.includes(:articles).exists?(articles: {id: id})
-      # #=> Perform `preload` behavior and `ActiveRecord::StatementInvalid` error occurs.
-      # ----
+      #   Author.includes(:articles).exists?(articles: {id: id})
+      #   #=> Perform `preload` behavior and `ActiveRecord::StatementInvalid` error occurs.
+      #   ----
       #
       # @example EnforcedStyle: exists (default)
       #   # bad
@@ -104,7 +105,7 @@ module RuboCop
           if exists_style?
             node.receiver.loc.selector.join(node.loc.selector)
           elsif where_style?
-            node.loc.selector.with(end_pos: node.loc.expression.end_pos)
+            node.loc.selector.with(end_pos: node.source_range.end_pos)
           end
         end