rubocop-rails 2.13.1 → 2.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 624c6bfb8dc9c5db0f6dd6bec835bd71e5e5a7aadc298342c15faae187226079
-  data.tar.gz: 4354d39a8367f0e4cb46b5a890cdd0836bfff6d838b5ae320b3df3a480f529af
+  metadata.gz: c8ac7c4db62e8518ff9316e0a3ac8919ac440eaf9ba84eacf883cf902fffca7a
+  data.tar.gz: 8a4b1e0c90e4ea2b8ba06352bc7525b56c4d95af49e618fb77a6bfd4bc5dafdb
 SHA512:
-  metadata.gz: 19863e8b5b71b4403d66b46e73ed41ceb1953d2a68996fbcc800ab4c06fcf4dfebadf3907f62d2c575b002223a95fa67fce2412c01fa42b6234848c2791b37e9
-  data.tar.gz: 1e3d14e3240f7fdb9182529865ee8257cf19368bac19c33abfba44b0a3b63c54e64457f73725e6c629a5846ea402a96e650f7d6ce0e1943386c857d6a8642d7b
+  metadata.gz: fb91cd3a6e867309efc10717843f0994a743bf1a4eb65b058863340d48904624377e88bb1b38cc0e091b9c2d5c676901987c1a31c3f6f50e5923863feb11f900
+  data.tar.gz: fe8208f3d1962a6c5400c74ab174b7b5b8c88641a564616f155cf90d91915ea85b6de031dc99a9737eb93fe3c39d878507f52d7f0aed85480142f630d0a082f5

data/config/default.yml

@@ -7,7 +7,9 @@ inherit_mode:
 AllCops:
   Exclude:
     - bin/*
-    - db/schema.rb
+    # Exclude db/schema.rb and db/[CONFIGURATION_NAMESPACE]_schema.rb by default.
+    # See: https://guides.rubyonrails.org/active_record_multiple_databases.html#setting-up-your-application
+    - db/*schema.rb
   # What version of Rails is the inspected code using?  If a value is specified
   # for TargetRailsVersion then it is used.  Acceptable values are specified
   # as a float (i.e. 5.1); the patch version of Rails should not be included.
@@ -38,6 +40,16 @@ Lint/NumberConversion:
     - fortnights
     - in_milliseconds
 
+Rails/ActionControllerTestCase:
+  Description: 'Use `ActionDispatch::IntegrationTest` instead of `ActionController::TestCase`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#integration-testing'
+  Reference: 'https://api.rubyonrails.org/classes/ActionController/TestCase.html'
+  Enabled: 'pending'
+  SafeAutocorrect: false
+  VersionAdded: '2.14'
+  Include:
+    - '**/test/**/*.rb'
+
 Rails/ActionFilter:
   Description: 'Enforces consistent use of action filter methods.'
   Enabled: true
@@ -195,9 +207,12 @@ Rails/ContentTag:
   Enabled: true
   VersionAdded: '2.6'
   VersionChanged: '2.12'
-  # This `Exclude` config prevents false positives for `tag` calls to `has_one: tag`. No helpers are used in normal models.
+  # This `Exclude` config prevents false positives for `tag` calls to `has_one: tag` and Puma configuration:
+  # https://puma.io/puma/Puma/DSL.html#tag-instance_method
+  # No helpers are used in normal models and configs.
   Exclude:
     - app/models/**/*.rb
+    - config/**/*.rb
 
 Rails/CreateTableWithTimestamps:
   Description: >-
@@ -251,6 +266,22 @@ Rails/DelegateAllowBlank:
   Enabled: true
   VersionAdded: '0.44'
 
+Rails/DeprecatedActiveModelErrorsMethods:
+  Description: 'Avoid manipulating ActiveModel errors hash directly.'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '2.14'
+
+Rails/DuplicateAssociation:
+  Description: "Don't repeat associations in a model."
+  Enabled: pending
+  VersionAdded: '2.14'
+
+Rails/DuplicateScope:
+  Description: 'Multiple scopes share this same where clause.'
+  Enabled: pending
+  VersionAdded: '2.14'
+
 Rails/DurationArithmetic:
   Description: 'Do not use duration as arithmetic operand with `Time.current`.'
   StyleGuide: 'https://rails.rubystyle.guide#duration-arithmetic'
@@ -415,6 +446,15 @@ Rails/HttpStatus:
     - numeric
     - symbolic
 
+Rails/I18nLazyLookup:
+  Description: 'Checks for places where I18n "lazy" lookup can be used.'
+  StyleGuide: 'https://rails.rubystyle.guide/#lazy-lookup'
+  Reference: 'https://guides.rubyonrails.org/i18n.html#lazy-lookup'
+  Enabled: pending
+  VersionAdded: '2.14'
+  Include:
+    - 'controllers/**/*'
+
 Rails/I18nLocaleAssignment:
   Description: 'Prefer the usage of `I18n.with_locale` instead of manually updating `I18n.locale` value.'
   Enabled: 'pending'
@@ -423,6 +463,12 @@ Rails/I18nLocaleAssignment:
     - spec/**/*.rb
     - test/**/*.rb
 
+Rails/I18nLocaleTexts:
+  Description: 'Enforces use of I18n and locale files instead of locale specific strings.'
+  StyleGuide: 'https://rails.rubystyle.guide/#locale-texts'
+  Enabled: pending
+  VersionAdded: '2.14'
+
 Rails/IgnoredSkipActionFilterOption:
   Description: 'Checks that `if` and `only` (or `except`) are not used together as options of `skip_*` action filter.'
   Reference: 'https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options'
@@ -453,6 +499,7 @@ Rails/InverseOf:
   Description: 'Checks for associations where the inverse cannot be determined automatically.'
   Enabled: true
   VersionAdded: '0.52'
+  IgnoreScopes: false
   Include:
     - app/models/**/*.rb
 
@@ -494,6 +541,13 @@ Rails/MatchRoute:
     - config/routes.rb
     - config/routes/**/*.rb
 
+Rails/MigrationClassName:
+  Description: 'The class name of the migration should match its file name.'
+  Enabled: pending
+  VersionAdded: '2.14'
+  Include:
+    - db/migrate/*.rb
+
 Rails/NegateInclude:
   Description: 'Prefer `collection.exclude?(obj)` over `!collection.include?(obj)`.'
   StyleGuide: 'https://rails.rubystyle.guide#exclude'
@@ -627,6 +681,7 @@ Rails/RedundantForeignKey:
 Rails/RedundantPresenceValidationOnBelongsTo:
   Description: 'Checks for redundant presence validation on belongs_to association.'
   Enabled: pending
+  SafeAutoCorrect: false
   VersionAdded: '2.13'
 
 Rails/RedundantReceiverInWithOptions:
@@ -702,15 +757,17 @@ Rails/ReversibleMigration:
   Reference: 'https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html'
   Enabled: true
   VersionAdded: '0.47'
+  VersionChanged: '2.13'
   Include:
-    - db/migrate/*.rb
+    - db/**/*.rb
 
 Rails/ReversibleMigrationMethodDefinition:
   Description: 'Checks whether the migration implements either a `change` method or both an `up` and a `down` method.'
   Enabled: false
   VersionAdded: '2.10'
+  VersionChanged: '2.13'
   Include:
-    - db/migrate/*.rb
+    - db/**/*.rb
 
 Rails/RootJoinChain:
   Description: 'Use a single `#join` instead of chaining on `Rails.root` or `Rails.public_path`.'
@@ -813,6 +870,15 @@ Rails/SquishedSQLHeredocs:
   # to be preserved in order to work, thus auto-correction is not safe.
   SafeAutoCorrect: false
 
+Rails/TableNameAssignment:
+  Description: >-
+    Do not use `self.table_name =`. Use Inflections or `table_name_prefix` instead.
+  StyleGuide: 'https://rails.rubystyle.guide/#keep-ar-defaults'
+  Enabled: false
+  VersionAdded: '2.14'
+  Include:
+    - app/models/**/*.rb
+
 Rails/TimeZone:
   Description: 'Checks the correct usage of time zone aware methods.'
   StyleGuide: 'https://rails.rubystyle.guide#time'
@@ -839,6 +905,11 @@ Rails/TimeZoneAssignment:
     - spec/**/*.rb
     - test/**/*.rb
 
+Rails/TransactionExitStatement:
+  Description: 'Avoid the usage of `return`, `break` and `throw` in transaction blocks.'
+  Enabled: pending
+  VersionAdded: '2.14'
+
 Rails/UniqBeforePluck:
   Description: 'Prefer the use of uniq or distinct before pluck.'
   Enabled: true

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A mixin to return all of the class send nodes.
+    module ClassSendNodeHelper
+      def class_send_nodes(class_node)
+        class_def = class_node.body
+
+        return [] unless class_def
+
+        if class_def.send_type?
+          [class_def]
+        else
+          class_def.each_child_node(:send)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops working with migrations
+    module MigrationsHelper
+      extend NodePattern::Macros
+
+      def_node_matcher :migration_class?, <<~PATTERN
+        (class
+          (const nil? _)
+          (send
+            (const (const {nil? cbase} :ActiveRecord) :Migration)
+            :[]
+            (float _))
+          _)
+      PATTERN
+
+      def in_migration?(node)
+        node.each_ancestor(:class).any? do |class_node|
+          migration_class?(class_node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Using `ActionController::TestCase`` is discouraged and should be replaced by
+      # `ActionDispatch::IntegrationTest``. Controller tests are too close to the
+      # internals of a controller whereas integration tests mimic the browser/user.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because the API of each test case class is different.
+      #   Make sure to update each test of your controller test cases after changing the superclass.
+      #
+      # @example
+      #   # bad
+      #   class MyControllerTest < ActionController::TestCase
+      #   end
+      #
+      #   # good
+      #   class MyControllerTest < ActionDispatch::IntegrationTest
+      #   end
+      #
+      class ActionControllerTestCase < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `ActionDispatch::IntegrationTest` instead.'
+
+        minimum_target_rails_version 5.0
+
+        def_node_matcher :action_controller_test_case?, <<~PATTERN
+          (class
+            (const nil? _)
+            (const (const {nil? cbase} :ActionController) :TestCase) nil?)
+        PATTERN
+
+        def on_class(node)
+          return unless action_controller_test_case?(node)
+
+          add_offense(node.parent_class) do |corrector|
+            corrector.replace(node.parent_class, 'ActionDispatch::IntegrationTest')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -32,6 +32,8 @@ module RuboCop
       #   after_update_commit :log_update_action
       #
       class AfterCommitOverride < Base
+        include ClassSendNodeHelper
+
         MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
 
         AFTER_COMMIT_CALLBACKS = %i[
@@ -63,18 +65,6 @@ module RuboCop
           end
         end
 
-        def class_send_nodes(class_node)
-          class_def = class_node.body
-
-          return [] unless class_def
-
-          if class_def.send_type?
-            [class_def]
-          else
-            class_def.each_child_node(:send).to_a
-          end
-        end
-
         def after_commit_callback?(node)
           AFTER_COMMIT_CALLBACKS.include?(node.method_name)
         end

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

@@ -155,17 +155,31 @@ module RuboCop
           return if include_bulk_options?(node)
           return unless node.block_node
 
-          send_nodes = node.block_node.body.each_child_node(:send).to_a
+          send_nodes = send_nodes_from_change_table_block(node.block_node.body)
 
-          transformations = send_nodes.select do |send_node|
-            combinable_transformations.include?(send_node.method_name)
-          end
-
-          add_offense_for_change_table(node) if transformations.size > 1
+          add_offense_for_change_table(node) if count_transformations(send_nodes) > 1
         end
 
         private
 
+        def send_nodes_from_change_table_block(body)
+          if body.send_type?
+            [body]
+          else
+            body.each_child_node(:send).to_a
+          end
+        end
+
+        def count_transformations(send_nodes)
+          send_nodes.sum do |node|
+            if node.method?(:remove)
+              node.arguments.count { |arg| !arg.hash_type? }
+            else
+              combinable_transformations.include?(node.method_name) ? 1 : 0
+            end
+          end
+        end
+
         # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
         def include_bulk_options?(node)
           # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]

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

@@ -10,25 +10,29 @@ module RuboCop
       #   blank check of block arguments to the receiver object.
       #
       #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.blank? }` and
-      #   `[[1, 2], [3, nil]].compact_blank` are not compatible. The same is true for `empty?`.
+      #   `[[1, 2], [3, nil]].compact_blank` are not compatible. The same is true for `blank?`.
       #   This will work fine when the receiver is a hash object.
       #
+      #   And `compact_blank!` has different implementations for `Array`, `Hash`, and
+      #   `ActionController::Parameters`.
+      #   `Array#compact_blank!`, `Hash#compact_blank!` are equivalent to `delete_if(&:blank?)`.
+      #   `ActionController::Parameters#compact_blank!` is equivalent to `reject!(&:blank?)`.
+      #   If the cop makes a mistake, auto-corrected code may get unexpected behavior.
+      #
       # @example
       #
       #   # bad
       #   collection.reject(&:blank?)
-      #   collection.reject(&:empty?)
       #   collection.reject { |_k, v| v.blank? }
-      #   collection.reject { |_k, v| v.empty? }
       #
       #   # good
       #   collection.compact_blank
       #
       #   # bad
-      #   collection.reject!(&:blank?)
-      #   collection.reject!(&:empty?)
-      #   collection.reject! { |_k, v| v.blank? }
-      #   collection.reject! { |_k, v| v.empty? }
+      #   collection.delete_if(&:blank?)            # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.delete_if { |_k, v| v.blank? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.reject!(&:blank?)              # Same behavior as `ActionController::Parameters#compact_blank!`
+      #   collection.reject! { |_k, v| v.blank? }   # Same behavior as `ActionController::Parameters#compact_blank!`
       #
       #   # good
       #   collection.compact_blank!
@@ -39,22 +43,22 @@ module RuboCop
         extend TargetRailsVersion
 
         MSG = 'Use `%<preferred_method>s` instead.'
-        RESTRICT_ON_SEND = %i[reject reject!].freeze
+        RESTRICT_ON_SEND = %i[reject delete_if reject!].freeze
 
         minimum_target_rails_version 6.1
 
         def_node_matcher :reject_with_block?, <<~PATTERN
           (block
-            (send _ {:reject :reject!})
+            (send _ {:reject :delete_if :reject!})
             $(args ...)
             (send
-              $(lvar _) {:blank? :empty?}))
+              $(lvar _) :blank?))
         PATTERN
 
         def_node_matcher :reject_with_block_pass?, <<~PATTERN
-          (send _ {:reject :reject!}
+          (send _ {:reject :delete_if :reject!}
             (block_pass
-              (sym {:blank? :empty?})))
+              (sym :blank?)))
         PATTERN
 
         def on_send(node)
@@ -73,12 +77,17 @@ module RuboCop
           return true if reject_with_block_pass?(node)
 
           if (arguments, receiver_in_block = reject_with_block?(node.parent))
-            return arguments.length == 1 || use_hash_value_block_argument?(arguments, receiver_in_block)
+            return use_single_value_block_argument?(arguments, receiver_in_block) ||
+                   use_hash_value_block_argument?(arguments, receiver_in_block)
           end
 
           false
         end
 
+        def use_single_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 1 && arguments[0].source == receiver_in_block.source
+        end
+
         def use_hash_value_block_argument?(arguments, receiver_in_block)
           arguments.length == 2 && arguments[1].source == receiver_in_block.source
         end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks direct manipulation of ActiveModel#errors as hash.
+      # These operations are deprecated in Rails 6.1 and will not work in Rails 7.
+      #
+      # @safety
+      #   This cop is unsafe because it can report `errors` manipulation on non-ActiveModel,
+      #   which is obviously valid.
+      #   The cop has no way of knowing whether a variable is an ActiveModel or not.
+      #
+      # @example
+      #   # bad
+      #   user.errors[:name] << 'msg'
+      #   user.errors.messages[:name] << 'msg'
+      #
+      #   # good
+      #   user.errors.add(:name, 'msg')
+      #
+      #   # bad
+      #   user.errors[:name].clear
+      #   user.errors.messages[:name].clear
+      #
+      #   # good
+      #   user.errors.delete(:name)
+      #
+      class DeprecatedActiveModelErrorsMethods < Base
+        MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
+
+        MANIPULATIVE_METHODS = Set[
+          *%i[
+            << append clear collect! compact! concat
+            delete delete_at delete_if drop drop_while fill filter! keep_if
+            flatten! insert map! pop prepend push reject! replace reverse!
+            rotate! select! shift shuffle! slice! sort! sort_by! uniq! unshift
+          ]
+        ].freeze
+
+        def_node_matcher :receiver_matcher_outside_model, '{send ivar lvar}'
+        def_node_matcher :receiver_matcher_inside_model, '{nil? send ivar lvar}'
+
+        def_node_matcher :any_manipulation?, <<~PATTERN
+          {
+            #root_manipulation?
+            #root_assignment?
+            #messages_details_manipulation?
+            #messages_details_assignment?
+          }
+        PATTERN
+
+        def_node_matcher :root_manipulation?, <<~PATTERN
+          (send
+            (send
+              (send #receiver_matcher :errors) :[] ...)
+            MANIPULATIVE_METHODS
+            ...
+          )
+        PATTERN
+
+        def_node_matcher :root_assignment?, <<~PATTERN
+          (send
+            (send #receiver_matcher :errors)
+            :[]=
+            ...)
+        PATTERN
+
+        def_node_matcher :messages_details_manipulation?, <<~PATTERN
+          (send
+            (send
+              (send
+                (send #receiver_matcher :errors)
+                {:messages :details})
+                :[]
+                ...)
+              MANIPULATIVE_METHODS
+            ...)
+        PATTERN
+
+        def_node_matcher :messages_details_assignment?, <<~PATTERN
+          (send
+            (send
+              (send #receiver_matcher :errors)
+              {:messages :details})
+            :[]=
+            ...)
+        PATTERN
+
+        def on_send(node)
+          any_manipulation?(node) do
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def receiver_matcher(node)
+          model_file? ? receiver_matcher_inside_model(node) : receiver_matcher_outside_model(node)
+        end
+
+        def model_file?
+          processed_source.buffer.name.include?('/models/')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for associations that have been defined multiple times in the same file.
+      #
+      # When an association is defined multiple times on a model, Active Record overrides the
+      # previously defined association with the new one. Because of this, this cop's autocorrection
+      # simply keeps the last of any duplicates and discards the rest.
+      #
+      # @example
+      #
+      #   # bad
+      #   belongs_to :foo
+      #   belongs_to :bar
+      #   has_one :foo
+      #
+      #   # good
+      #   belongs_to :bar
+      #   has_one :foo
+      #
+      class DuplicateAssociation < Base
+        include RangeHelp
+        extend AutoCorrector
+        include ClassSendNodeHelper
+
+        MSG = "Association `%<name>s` is defined multiple times. Don't repeat associations."
+
+        def_node_matcher :association, <<~PATTERN
+          (send nil? {:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_) ...)
+        PATTERN
+
+        def on_class(class_node)
+          offenses(class_node).each do |name, nodes|
+            nodes.each do |node|
+              add_offense(node, message: format(MSG, name: name)) do |corrector|
+                next if nodes.last == node
+
+                corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+              end
+            end
+          end
+        end
+
+        private
+
+        def offenses(class_node)
+          class_send_nodes(class_node).select { |node| association(node) }
+                                      .group_by { |node| association(node).to_sym }
+                                      .select { |_, nodes| nodes.length > 1 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for multiple scopes in a model that have the same `where` clause. This
+      # often means you copy/pasted a scope, updated the name, and forgot to change the condition.
+      #
+      # @example
+      #
+      #   # bad
+      #   scope :visible, -> { where(visible: true) }
+      #   scope :hidden, -> { where(visible: true) }
+      #
+      #   # good
+      #   scope :visible, -> { where(visible: true) }
+      #   scope :hidden, -> { where(visible: false) }
+      #
+      class DuplicateScope < Base
+        include ClassSendNodeHelper
+
+        MSG = 'Multiple scopes share this same where clause.'
+
+        def_node_matcher :scope, <<~PATTERN
+          (send nil? :scope _ $...)
+        PATTERN
+
+        def on_class(class_node)
+          offenses(class_node).each do |node|
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def offenses(class_node)
+          class_send_nodes(class_node).select { |node| scope(node) }
+                                      .group_by { |node| scope(node) }
+                                      .select { |_, nodes| nodes.length > 1 }
+                                      .values
+                                      .flatten
+        end
+      end
+    end
+  end
+end

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

@@ -26,7 +26,8 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ -].freeze
 
         DURATIONS = Set[:second, :seconds, :minute, :minutes, :hour, :hours,
-                        :day, :days, :week, :weeks, :fortnight, :fortnights]
+                        :day, :days, :week, :weeks, :fortnight, :fortnights,
+                        :month, :months, :year, :years]
 
         # @!method duration_arithmetic_argument?(node)
         #   Match duration subtraction or addition with current time.