rubocop-rails 2.7.1 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cffb4c138d270540b5821e23b2c5450a1939d4b01a2720ce400a8bb510ff90c
-  data.tar.gz: e0702c6ae4a7a43a01034b32d64ad67bac55659d6a5ec471685bda3c6d2a43fe
+  metadata.gz: 6e89f00783e4dce6642e43ba4a4bf8ee29d078131f71404230db8fd2a1f87248
+  data.tar.gz: bfbca38eb400e89e260b572babc327afec01b25bad89178179e8276ef7ce651c
 SHA512:
-  metadata.gz: 0ce7f6953d24239b8ce71a2e759da5007eb94a752f34ccb8d738273f5f75c63f57664042964f9766652c16e076996bb294edafc7d687a923c60ae2f56328afd3
-  data.tar.gz: b810b20d35548b34813946fff138c204fe0ce4f64a68b2f09e63a69c102ad44cf476a543b8bcf87f9caf42d5312ec277e14d23650100df21fb27fb14cc246216
+  metadata.gz: 241d43809d5cbfa4684fa83c1b92c9069447bae05ca0235d137e6934a2a9ad35ff3e00fba46928e793045ee1cf35dc3a520cca9f177e8c3280530282eb52ac06
+  data.tar.gz: 7019b400331651ad86a94e9562f93e31c32025ae5ed9c8c5da0f62c65974b21052438908a535da9314a6b903ea3ff6815dc7a0a6350ce3db9d6ab1d0ac18d015

data/config/default.yml

@@ -62,6 +62,14 @@ Rails/ActiveSupportAliases:
   Enabled: true
   VersionAdded: '0.48'
 
+Rails/AfterCommitOverride:
+  Description: >-
+                  This cop enforces that there is only one call to `after_commit`
+                  (and its aliases - `after_create_commit`, `after_update_commit`,
+                  and `after_destroy_commit`) with the same callback name per model.
+  Enabled: 'pending'
+  VersionAdded: '2.8'
+
 Rails/ApplicationController:
   Description: 'Check that controllers subclass ApplicationController.'
   Enabled: true
@@ -313,14 +321,16 @@ Rails/IgnoredSkipActionFilterOption:
     - app/controllers/**/*.rb
 
 Rails/IndexBy:
-  Description: 'Prefer `index_by` over `each_with_object` or `map`.'
+  Description: 'Prefer `index_by` over `each_with_object`, `to_h`, or `map`.'
   Enabled: true
   VersionAdded: '2.5'
+  VersionChanged: '2.8'
 
 Rails/IndexWith:
-  Description: 'Prefer `index_with` over `each_with_object` or `map`.'
+  Description: 'Prefer `index_with` over `each_with_object`, `to_h`, or `map`.'
   Enabled: true
   VersionAdded: '2.5'
+  VersionChanged: '2.8'
 
 Rails/Inquiry:
   Description: "Prefer Ruby's comparison operators over Active Support's `Array#inquiry` and `String#inquiry`."
@@ -357,6 +367,7 @@ Rails/MailerName:
   Description: 'Mailer should end with `Mailer` suffix.'
   StyleGuide: 'https://rails.rubystyle.guide/#mailer-name'
   Enabled: 'pending'
+  SafeAutoCorrect: false
   VersionAdded: '2.7'
   Include:
     - app/mailers/**/*.rb
@@ -385,6 +396,14 @@ Rails/NotNullColumn:
   Include:
     - db/migrate/*.rb
 
+Rails/OrderById:
+  Description: >-
+                  Do not use the `id` column for ordering.
+                  Use a timestamp column to order chronologically.
+  StyleGuide: 'https://rails.rubystyle.guide/#order-by-id'
+  Enabled: false
+  VersionAdded: '2.8'
+
 Rails/Output:
   Description: 'Checks for calls to puts, print, etc.'
   Enabled: true
@@ -426,6 +445,11 @@ Rails/PluckInWhere:
   Enabled: 'pending'
   Safe: false
   VersionAdded: '2.7'
+  VersionChanged: '2.8'
+  EnforcedStyle: conservative
+  SupportedStyles:
+    - conservative
+    - aggressive
 
 Rails/PluralizationGrammar:
   Description: 'Checks for incorrect grammar when using methods like `3.day.ago`.'
@@ -624,6 +648,12 @@ Rails/SkipsModelValidations:
     - upsert_all
   AllowedMethods: []
 
+Rails/SquishedSQLHeredocs:
+  Description: 'Checks SQL heredocs to use `.squish`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#squished-heredocs'
+  Enabled: 'pending'
+  VersionAdded: '2.8'
+
 Rails/TimeZone:
   Description: 'Checks the correct usage of time zone aware methods.'
   StyleGuide: 'https://rails.rubystyle.guide#time'
@@ -643,11 +673,12 @@ Rails/UniqBeforePluck:
   Description: 'Prefer the use of uniq or distinct before pluck.'
   Enabled: true
   VersionAdded: '0.40'
-  VersionChanged: '2.6'
+  VersionChanged: '2.8'
   EnforcedStyle: conservative
   SupportedStyles:
     - conservative
     - aggressive
+  SafeAutoCorrect: false
   AutoCorrect: false
 
 Rails/UniqueValidationWithoutIndex:
@@ -677,7 +708,18 @@ Rails/Validation:
 Rails/WhereExists:
   Description: 'Prefer `exists?(...)` over `where(...).exists?`.'
   Enabled: 'pending'
+  EnforcedStyle: exists
+  SupportedStyles:
+    - exists
+    - where
   VersionAdded: '2.7'
+  VersionChanged: '2.8'
+
+Rails/WhereNot:
+  Description: 'Use `where.not(...)` instead of manually constructing negated SQL in `where`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#where-not'
+  Enabled: 'pending'
+  VersionAdded: '2.8'
 
 # Accept `redirect_to(...) and return` and similar cases.
 Style/AndOr:

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

@@ -8,6 +8,12 @@ module RuboCop
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
+
+        return if target_ruby_version < 2.6
+
+        on_bad_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'to_h { ... }')
+        end
       end
 
       def on_send(node)
@@ -40,6 +46,11 @@ module RuboCop
         raise NotImplementedError
       end
 
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_to_h(_node)
+        raise NotImplementedError
+      end
+
       # @abstract Implemented with `def_node_matcher`
       def on_bad_map_to_h(_node)
         raise NotImplementedError
@@ -73,6 +84,8 @@ module RuboCop
       def prepare_correction(node)
         if (match = on_bad_each_with_object(node))
           Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_to_h(node))
+          Autocorrection.from_to_h(node, match)
         elsif (match = on_bad_map_to_h(node))
           Autocorrection.from_map_to_h(node, match)
         elsif (match = on_bad_hash_brackets_map(node))
@@ -111,6 +124,10 @@ module RuboCop
           new(match, node, 0, 0)
         end
 
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
         def self.from_map_to_h(node, match)
           strip_trailing_chars = 0
 

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

@@ -44,9 +44,7 @@ module RuboCop
           after_touch
         ].freeze
 
-        CALLBACKS_ORDER_MAP = Hash[
-          CALLBACKS_IN_ORDER.map.with_index { |name, index| [name, index] }
-        ].freeze
+        CALLBACKS_ORDER_MAP = CALLBACKS_IN_ORDER.each_with_index.to_h.freeze
 
         def on_class(class_node)
           previous_index = -1
@@ -68,7 +66,7 @@ module RuboCop
 
         # Autocorrect by swapping between two nodes autocorrecting them
         def autocorrect(node)
-          previous = left_siblings_of(node).find do |sibling|
+          previous = left_siblings_of(node).reverse_each.find do |sibling|
             callback?(sibling)
           end
 

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that there is only one call to `after_commit`
+      # (and its aliases - `after_create_commit`, `after_update_commit`,
+      # and `after_destroy_commit`) with the same callback name per model.
+      #
+      # @example
+      #   # bad
+      #   # This won't be triggered.
+      #   after_create_commit :log_action
+      #
+      #   # This will override the callback added by
+      #   # after_create_commit.
+      #   after_update_commit :log_action
+      #
+      #   # bad
+      #   # This won't be triggered.
+      #   after_commit :log_action, on: :create
+      #   # This won't be triggered.
+      #   after_update_commit :log_action
+      #   # This will override both previous callbacks.
+      #   after_commit :log_action, on: :destroy
+      #
+      #   # good
+      #   after_save_commit :log_action
+      #
+      #   # good
+      #   after_create_commit :log_create_action
+      #   after_update_commit :log_update_action
+      #
+      class AfterCommitOverride < Cop
+        MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
+
+        AFTER_COMMIT_CALLBACKS = %i[
+          after_commit
+          after_create_commit
+          after_update_commit
+          after_save_commit
+          after_destroy_commit
+        ].freeze
+
+        def on_class(class_node)
+          seen_callback_names = {}
+
+          each_after_commit_callback(class_node) do |node|
+            callback_name = node.arguments[0].value
+            if seen_callback_names.key?(callback_name)
+              add_offense(node, message: format(MSG, name: callback_name))
+            else
+              seen_callback_names[callback_name] = true
+            end
+          end
+        end
+
+        private
+
+        def each_after_commit_callback(class_node)
+          class_send_nodes(class_node).each do |node|
+            yield node if after_commit_callback?(node)
+          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
+      end
+    end
+  end
+end

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

@@ -43,7 +43,7 @@ module RuboCop
               range = correction_range(node)
 
               rest_args = node.arguments.drop(1)
-              replacement = "tag.#{node.first_argument.value}(#{rest_args.map(&:source).join(', ')})"
+              replacement = "tag.#{node.first_argument.value.to_s.underscore}(#{rest_args.map(&:source).join(', ')})"
 
               corrector.replace(range, replacement)
             else
@@ -57,7 +57,7 @@ module RuboCop
         def method_name?(node)
           return false unless node.str_type? || node.sym_type?
 
-          /^[a-zA-Z_][a-zA-Z_0-9]*$/.match?(node.value)
+          /^[a-zA-Z_][a-zA-Z_\-0-9]*$/.match?(node.value)
         end
 
         def correction_range(node)

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source.match?(%r{/})
+          node.str_type? && node.source.include?('/')
         end
 
         def register_offense(node)

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

@@ -52,11 +52,7 @@ module RuboCop
 
         def on_send(node)
           return if active_resource?(node.parent)
-
-          unless association_without_options?(node)
-            return if valid_options?(association_with_options?(node))
-          end
-
+          return if !association_without_options?(node) && valid_options?(association_with_options?(node))
           return if valid_options_in_with_options_block?(node)
 
           add_offense(node, location: :selector)

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

@@ -31,6 +31,8 @@ module RuboCop
         end
 
         def on_ivasgn(node)
+          return if node.parent.or_asgn_type?
+
           add_offense(node, location: :name)
         end
       end

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

@@ -11,6 +11,7 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2, 3].each_with_object({}) { |el, h| h[foo(el)] = el }
+      #   [1, 2, 3].to_h { |el| [foo(el), el] }
       #   [1, 2, 3].map { |el| [foo(el), el] }.to_h
       #   Hash[[1, 2, 3].collect { |el| [foo(el), el] }]
       #
@@ -26,6 +27,13 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $_ (lvar _el)))
         PATTERN
 
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} _ :to_h)
+            (args (arg $_el))
+            (array $_ (lvar _el)))
+        PATTERN
+
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block

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

@@ -11,6 +11,7 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2, 3].each_with_object({}) { |el, h| h[el] = foo(el) }
+      #   [1, 2, 3].to_h { |el| [el, foo(el)] }
       #   [1, 2, 3].map { |el| [el, foo(el)] }.to_h
       #   Hash[[1, 2, 3].collect { |el| [el, foo(el)] }]
       #
@@ -29,6 +30,13 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= (lvar _el) $_))
         PATTERN
 
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} _ :to_h)
+            (args (arg $_el))
+            (array (lvar _el) $_))
+        PATTERN
+
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block

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

@@ -26,7 +26,11 @@ module RuboCop
         MSG = "Prefer Ruby's comparison operators over Active Support's `inquiry`."
 
         def on_send(node)
-          add_offense(node, location: :selector) if node.method?(:inquiry) && node.arguments.empty?
+          return unless node.method?(:inquiry) && node.arguments.empty?
+          return unless (receiver = node.receiver)
+          return if !receiver.str_type? && !receiver.array_type?
+
+          add_offense(node, location: :selector)
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for places where ordering by `id` column is used.
+      #
+      # Don't use the `id` column for ordering. The sequence of ids is not guaranteed
+      # to be in any particular order, despite often (incidentally) being chronological.
+      # Use a timestamp column to order chronologically. As a bonus the intent is clearer.
+      #
+      # NOTE: Make sure the changed order column does not introduce performance
+      # bottlenecks and appropriate database indexes are added.
+      #
+      # @example
+      #   # bad
+      #   scope :chronological, -> { order(id: :asc) }
+      #   scope :chronological, -> { order(primary_key => :asc) }
+      #
+      #   # good
+      #   scope :chronological, -> { order(created_at: :asc) }
+      #
+      class OrderById < Base
+        include RangeHelp
+
+        MSG = 'Do not use the `id` column for ordering. '\
+              'Use a timestamp column to order chronologically.'
+
+        def_node_matcher :order_by_id?, <<~PATTERN
+          (send _ :order
+            {
+              (sym :id)
+              (hash (pair (sym :id) _))
+              (send _ :primary_key)
+              (hash (pair (send _ :primary_key) _))
+            })
+        PATTERN
+
+        def on_send(node)
+          return unless node.method?(:order)
+
+          add_offense(offense_range(node)) if order_by_id?(node)
+        end
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -9,20 +9,42 @@ module RuboCop
       # Since `pluck` is an eager method and hits the database immediately,
       # using `select` helps to avoid additional database queries.
       #
+      # 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) in the `where` is used as offenses.
+      #
+      # When the EnforcedStyle is aggressive then all calls to `pluck` in the
+      # `where` is used as offenses. This may lead to false positives
+      # as the cop cannot replace to `select` between calls to `pluck` on an
+      # `ActiveRecord::Relation` instance vs a call to `pluck` on an `Array` instance.
+      #
       # @example
       #   # bad
       #   Post.where(user_id: User.active.pluck(:id))
       #
       #   # good
       #   Post.where(user_id: User.active.select(:id))
+      #   Post.where(user_id: active_users.select(:id))
+      #
+      # @example EnforcedStyle: conservative (default)
+      #   # good
+      #   Post.where(user_id: active_users.pluck(:id))
+      #
+      # @example EnforcedStyle: aggressive
+      #   # bad
+      #   Post.where(user_id: active_users.pluck(:id))
       #
       class PluckInWhere < Cop
         include ActiveRecordHelper
+        include ConfigurableEnforcedStyle
 
         MSG = 'Use `select` instead of `pluck` within `where` query method.'
 
         def on_send(node)
-          add_offense(node, location: :selector) if node.method?(:pluck) && in_where?(node)
+          return unless node.method?(:pluck) && in_where?(node)
+          return if style == :conservative && !root_receiver(node)&.const_type?
+
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -30,6 +52,18 @@ module RuboCop
             corrector.replace(node.loc.selector, 'select')
           end
         end
+
+        private
+
+        def root_receiver(node)
+          receiver = node.receiver
+
+          if receiver&.send_type?
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
       end
     end
   end

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

@@ -17,7 +17,7 @@ module RuboCop
         MSG = 'Use a string value for `class_name`.'
 
         def_node_matcher :association_with_reflection, <<~PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _
+          (send nil? {:has_many :has_one :belongs_to} _ _ ?
             (hash <$#reflection_class_name ...>)
           )
         PATTERN

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

@@ -49,8 +49,7 @@ module RuboCop
 
             relative_date?(value) do |method_name|
               add_offense(node,
-                          location: range_between(name.loc.expression.begin_pos,
-                                                  value.loc.expression.end_pos),
+                          location: offense_range(name, value),
                           message: format(MSG, method_name: method_name))
             end
           end
@@ -77,6 +76,10 @@ module RuboCop
 
         private
 
+        def offense_range(name, value)
+          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
+        end
+
         def_node_matcher :relative_date_assignment?, <<~PATTERN
           {
             (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))

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

@@ -129,6 +129,51 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # remove_columns
+      #
+      #   # bad
+      #   def change
+      #     remove_columns :users, :name, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       dir.up do
+      #         remove_columns :users, :name, :email
+      #       end
+      #
+      #       dir.down do
+      #         add_column :users, :name, :string
+      #         add_column :users, :email, :string
+      #       end
+      #     end
+      #   end
+      #
+      #   # good (Rails >= 6.1, see https://github.com/rails/rails/pull/36589)
+      #   def change
+      #     remove_columns :users, :name, :email, type: :string
+      #   end
+      #
+      # @example
+      #   # remove_index
+      #
+      #   # bad
+      #   def change
+      #     remove_index :users, name: :index_users_on_email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, column: :email
+      #   end
+      #
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
       class ReversibleMigration < Cop
         MSG = '%<action>s is not reversible.'
@@ -153,6 +198,14 @@ module RuboCop
           (send nil? :change_table $_ ...)
         PATTERN
 
+        def_node_matcher :remove_columns_call, <<~PATTERN
+          (send nil? :remove_columns ... $_)
+        PATTERN
+
+        def_node_matcher :remove_index_call, <<~PATTERN
+          (send nil? :remove_index _ $_)
+        PATTERN
+
         def on_send(node)
           return unless within_change_method?(node)
           return if within_reversible_or_up_only_block?(node)
@@ -162,6 +215,8 @@ module RuboCop
           check_reversible_hash_node(node)
           check_remove_column_node(node)
           check_remove_foreign_key_node(node)
+          check_remove_columns_node(node)
+          check_remove_index_node(node)
         end
 
         def on_block(node)
@@ -237,6 +292,30 @@ module RuboCop
           end
         end
 
+        def check_remove_columns_node(node)
+          remove_columns_call(node) do |args|
+            unless all_hash_key?(args, :type) && target_rails_version >= 6.1
+              action = target_rails_version >= 6.1 ? 'remove_columns(without type)' : 'remove_columns'
+
+              add_offense(
+                node,
+                message: format(MSG, action: action)
+              )
+            end
+          end
+        end
+
+        def check_remove_index_node(node)
+          remove_index_call(node) do |args|
+            if args.hash_type? && !all_hash_key?(args, :column)
+              add_offense(
+                node,
+                message: format(MSG, action: 'remove_index(without column)')
+              )
+            end
+          end
+        end
+
         def check_change_table_offense(receiver, node)
           method_name = node.method_name
           return if receiver != node.receiver &&

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

@@ -138,7 +138,7 @@ module RuboCop
           add_offense_for_node(node, CREATE_MSG)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless persist_method?(node)
           return if return_value_assigned?(node)
@@ -150,7 +150,7 @@ module RuboCop
 
           add_offense_for_node(node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         def autocorrect(node)

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Checks SQL heredocs to use `.squish`.
+      #
+      # @example
+      #   # bad
+      #   <<-SQL
+      #     SELECT * FROM posts;
+      #   SQL
+      #
+      #   <<-SQL
+      #     SELECT * FROM posts
+      #       WHERE id = 1
+      #   SQL
+      #
+      #   execute(<<~SQL, "Post Load")
+      #     SELECT * FROM posts
+      #       WHERE post_id = 1
+      #   SQL
+      #
+      #   # good
+      #   <<-SQL.squish
+      #     SELECT * FROM posts;
+      #   SQL
+      #
+      #   <<~SQL.squish
+      #     SELECT * FROM table
+      #       WHERE id = 1
+      #   SQL
+      #
+      #   execute(<<~SQL.squish, "Post Load")
+      #     SELECT * FROM posts
+      #       WHERE post_id = 1
+      #   SQL
+      #
+      class SquishedSQLHeredocs < Cop
+        include Heredoc
+
+        SQL = 'SQL'
+        SQUISH = '.squish'
+        MSG = 'Use `%<expect>s` instead of `%<current>s`.'
+
+        def on_heredoc(node)
+          return unless offense_detected?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.insert_after(node, SQUISH)
+          end
+        end
+
+        private
+
+        def offense_detected?(node)
+          sql_heredoc?(node) && !using_squish?(node)
+        end
+
+        def sql_heredoc?(node)
+          delimiter_string(node) == SQL
+        end
+
+        def using_squish?(node)
+          node.parent&.send_type? && node.parent&.method?(:squish)
+        end
+
+        def message(node)
+          format(
+            MSG,
+            expect: "#{node.source}#{SQUISH}",
+            current: node.source
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,8 @@ module RuboCop
       # 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.
       #

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

@@ -34,23 +34,25 @@ module RuboCop
           return unless uniqueness_part(node)
           return if condition_part?(node)
           return unless schema
-          return if with_index?(node)
+
+          klass, table, names = find_schema_information(node)
+          return unless names
+          return if with_index?(klass, table, names)
 
           add_offense(node)
         end
 
         private
 
-        def with_index?(node)
+        def find_schema_information(node)
           klass = class_node(node)
-          return true unless klass # Skip analysis
-
           table = schema.table_by(name: table_name(klass))
-          return true unless table # Skip analysis if it can't find the table
-
           names = column_names(node)
-          return true unless names
 
+          [klass, table, names]
+        end
+
+        def with_index?(klass, table, names)
           # Compatibility for Rails 4.2.
           add_indicies = schema.add_indicies_by(table_name: table_name(klass))
 
@@ -95,6 +97,8 @@ module RuboCop
           scope = find_scope(uniq)
           return unless scope
 
+          scope = unfreeze_scope(scope)
+
           case scope.type
           when :sym, :str
             [scope.value]
@@ -112,6 +116,10 @@ module RuboCop
           end
         end
 
+        def unfreeze_scope(scope)
+          scope.send_type? && scope.method?(:freeze) ? scope.children.first : scope
+        end
+
         def class_node(node)
           node.each_ancestor.find(&:class_type?)
         end

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

@@ -3,9 +3,15 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the use of `exists?(...)` over `where(...).exists?`.
+      # This cop enforces consistent style when using `exists?`.
       #
-      # @example
+      # Two styles are supported for this cop. When EnforcedStyle is 'exists'
+      # then the cop enforces `exists?(...)` over `where(...).exists?`.
+      #
+      # When EnforcedStyle is 'where' then the cop enforces
+      # `where(...).exists?` over `exists?(...)`.
+      #
+      # @example EnforcedStyle: exists (default)
       #   # bad
       #   User.where(name: 'john').exists?
       #   User.where(['name = ?', 'john']).exists?
@@ -17,15 +23,34 @@ module RuboCop
       #   User.where('length(name) > 10').exists?
       #   user.posts.exists?(published: true)
       #
+      # @example EnforcedStyle: where
+      #   # bad
+      #   User.exists?(name: 'john')
+      #   User.exists?(['name = ?', 'john'])
+      #   User.exists?('name = ?', 'john')
+      #   user.posts.exists?(published: true)
+      #
+      #   # good
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #   User.where('length(name) > 10').exists?
       class WhereExists < Cop
+        include ConfigurableEnforcedStyle
+
         MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
 
         def_node_matcher :where_exists_call?, <<~PATTERN
           (send (send _ :where $...) :exists?)
         PATTERN
 
+        def_node_matcher :exists_with_args?, <<~PATTERN
+          (send _ :exists? $...)
+        PATTERN
+
         def on_send(node)
-          where_exists_call?(node) do |args|
+          find_offenses(node) do |args|
             return unless convertable_args?(args)
 
             range = correction_range(node)
@@ -35,7 +60,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          args = where_exists_call?(node)
+          args = find_offenses(node)
 
           lambda do |corrector|
             corrector.replace(
@@ -47,21 +72,59 @@ module RuboCop
 
         private
 
+        def where_style?
+          style == :where
+        end
+
+        def exists_style?
+          style == :exists
+        end
+
+        def find_offenses(node, &block)
+          if exists_style?
+            where_exists_call?(node, &block)
+          elsif where_style?
+            exists_with_args?(node, &block)
+          end
+        end
+
         def convertable_args?(args)
+          return false if args.empty?
+
           args.size > 1 || args[0].hash_type? || args[0].array_type?
         end
 
         def correction_range(node)
-          node.receiver.loc.selector.join(node.loc.selector)
+          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)
+          end
         end
 
         def build_good_method(args)
+          if exists_style?
+            build_good_method_exists(args)
+          elsif where_style?
+            build_good_method_where(args)
+          end
+        end
+
+        def build_good_method_exists(args)
           if args.size > 1
             "exists?([#{args.map(&:source).join(', ')}])"
           else
             "exists?(#{args[0].source})"
           end
         end
+
+        def build_good_method_where(args)
+          if args.size > 1
+            "where(#{args.map(&:source).join(', ')}).exists?"
+          else
+            "where(#{args[0].source}).exists?"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where manually constructed SQL
+      # in `where` can be replaced with `where.not(...)`.
+      #
+      # @example
+      #   # bad
+      #   User.where('name != ?', 'Gabe')
+      #   User.where('name != :name', name: 'Gabe')
+      #   User.where('name IS NOT NULL')
+      #   User.where('name NOT IN (?)', ['john', 'jane'])
+      #   User.where('name NOT IN (:names)', names: ['john', 'jane'])
+      #
+      #   # good
+      #   User.where.not(name: 'Gabe')
+      #   User.where.not(name: nil)
+      #   User.where.not(name: ['john', 'jane'])
+      #
+      class WhereNot < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<good_method>s` instead of manually constructing negated SQL in `where`.'
+
+        def_node_matcher :where_method_call?, <<~PATTERN
+          {
+            (send _ :where (array $str_type? $_ ?))
+            (send _ :where $str_type? $_ ?)
+          }
+        PATTERN
+
+        def on_send(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
+
+            good_method = build_good_method(*column_and_value)
+            message = format(MSG, good_method: good_method)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          where_method_call?(node) do |template_node, value_node|
+            value_node = value_node.first
+
+            lambda do |corrector|
+              range = offense_range(node)
+
+              column, value = *extract_column_and_value(template_node, value_node)
+              replacement = build_good_method(column, value)
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        NOT_EQ_ANONYMOUS_RE = /\A([\w.]+)\s+!=\s+\?\z/.freeze                  # column != ?
+        NOT_IN_ANONYMOUS_RE = /\A([\w.]+)\s+NOT\s+IN\s+\(\?\)\z/i.freeze       # column NOT IN (?)
+        NOT_EQ_NAMED_RE     = /\A([\w.]+)\s+!=\s+:(\w+)\z/.freeze              # column != :column
+        NOT_IN_NAMED_RE     = /\A([\w.]+)\s+NOT\s+IN\s+\(:(\w+)\)\z/i.freeze   # column NOT IN (:column)
+        IS_NOT_NULL_RE      = /\A([\w.]+)\s+IS\s+NOT\s+NULL\z/i.freeze         # column IS NOT NULL
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        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
+            when NOT_EQ_NAMED_RE, NOT_IN_NAMED_RE
+              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
+            when IS_NOT_NULL_RE
+              'nil'
+            else
+              return
+            end
+
+          [Regexp.last_match(1), value]
+        end
+
+        def build_good_method(column, value)
+          if column.include?('.')
+            "where.not('#{column}' => #{value})"
+          else
+            "where.not(#{column}: #{value})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -9,6 +9,7 @@ require_relative 'rails/active_record_aliases'
 require_relative 'rails/active_record_callbacks_order'
 require_relative 'rails/active_record_override'
 require_relative 'rails/active_support_aliases'
+require_relative 'rails/after_commit_override'
 require_relative 'rails/application_controller'
 require_relative 'rails/application_job'
 require_relative 'rails/application_mailer'
@@ -48,6 +49,7 @@ require_relative 'rails/mailer_name'
 require_relative 'rails/match_route'
 require_relative 'rails/negate_include'
 require_relative 'rails/not_null_column'
+require_relative 'rails/order_by_id'
 require_relative 'rails/output'
 require_relative 'rails/output_safety'
 require_relative 'rails/pick'
@@ -75,9 +77,11 @@ require_relative 'rails/save_bang'
 require_relative 'rails/scope_args'
 require_relative 'rails/short_i18n'
 require_relative 'rails/skips_model_validations'
+require_relative 'rails/squished_sql_heredocs'
 require_relative 'rails/time_zone'
 require_relative 'rails/uniq_before_pluck'
 require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
 require_relative 'rails/validation'
 require_relative 'rails/where_exists'
+require_relative 'rails/where_not'

data/lib/rubocop/rails/schema_loader/schema.rb

@@ -97,14 +97,12 @@ module RuboCop
           end.compact
         end
 
-        def each_content(node)
+        def each_content(node, &block)
           return enum_for(__method__, node) unless block_given?
 
           case node.body&.type
           when :begin
-            node.body.children.each do |child|
-              yield(child)
-            end
+            node.body.children.each(&block)
           else
             yield(node.body)
           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.7.1'
+      STRING = '2.8.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rails
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 2.8.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-26 00:00:00.000000000 Z
+date: 2020-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -77,6 +77,7 @@ files:
 - lib/rubocop/cop/rails/active_record_callbacks_order.rb
 - lib/rubocop/cop/rails/active_record_override.rb
 - lib/rubocop/cop/rails/active_support_aliases.rb
+- lib/rubocop/cop/rails/after_commit_override.rb
 - lib/rubocop/cop/rails/application_controller.rb
 - lib/rubocop/cop/rails/application_job.rb
 - lib/rubocop/cop/rails/application_mailer.rb
@@ -116,6 +117,7 @@ files:
 - lib/rubocop/cop/rails/match_route.rb
 - lib/rubocop/cop/rails/negate_include.rb
 - lib/rubocop/cop/rails/not_null_column.rb
+- lib/rubocop/cop/rails/order_by_id.rb
 - lib/rubocop/cop/rails/output.rb
 - lib/rubocop/cop/rails/output_safety.rb
 - lib/rubocop/cop/rails/pick.rb
@@ -143,12 +145,14 @@ files:
 - lib/rubocop/cop/rails/scope_args.rb
 - lib/rubocop/cop/rails/short_i18n.rb
 - lib/rubocop/cop/rails/skips_model_validations.rb
+- lib/rubocop/cop/rails/squished_sql_heredocs.rb
 - lib/rubocop/cop/rails/time_zone.rb
 - lib/rubocop/cop/rails/uniq_before_pluck.rb
 - lib/rubocop/cop/rails/unique_validation_without_index.rb
 - lib/rubocop/cop/rails/unknown_env.rb
 - lib/rubocop/cop/rails/validation.rb
 - lib/rubocop/cop/rails/where_exists.rb
+- lib/rubocop/cop/rails/where_not.rb
 - lib/rubocop/cop/rails_cops.rb
 - lib/rubocop/rails.rb
 - lib/rubocop/rails/inject.rb