rubocop-rails 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6b55ee8df864d6eaee4a491f4324343ee2274eafcb352952a81ff045832aa22
-  data.tar.gz: 344ea324a589dc25ce3e87366c4af33bde4e392acf6acaccf9b9296066680824
+  metadata.gz: 5a83fc9ded75b4055903b32234c6c9b878e76b22ee64b7e0d88cf2f54ac690d5
+  data.tar.gz: cb9cbde85b8117645e16c66d1670cffc61893eba8b5d5e3f530e7e42d81b147f
 SHA512:
-  metadata.gz: 5bdccc2a5e2a45533cb5bb33b2df26872f806dd590c13d640d7449315e56ec6250aebdb876fb37812bb3dd47cdaeda61c6049bc5cf98b01b473a616e9061491b
-  data.tar.gz: 6f8673f2e8d0068bcdbe1599936793461bab38f4b333a4ac6e22e03e7162851d6fc20543ec58e3f2fabdf404764b09f8ff47e6a5c23d492f0c8bb28acd012296
+  metadata.gz: 9df513d510b7a71d81bcf655088528ca642599702eca3f20d83eac18adcc15a3d2ab277760b78b9f86fc90df474409eaee454c6857623a2f459304fb74fdde00
+  data.tar.gz: 252a9b09c51b33b4ff53454fcc6ccaec41e719c283939475e643074305221a33652a9ab5649b9b2c51f36784bb67eeef5dbceee9b3852de936fed78073241dc0

data/config/default.yml

@@ -37,6 +37,14 @@ Rails/ActiveRecordAliases:
   VersionAdded: '0.53'
   SafeAutoCorrect: false
 
+Rails/ActiveRecordCallbacksOrder:
+  Description: 'Order callback declarations in the order in which they will be executed.'
+  StyleGuide: 'https://rails.rubystyle.guide/#callbacks-order'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+  Include:
+    - app/models/**/*.rb
+
 Rails/ActiveRecordOverride:
   Description: >-
                   Check for overriding Active Record methods instead of using
@@ -153,6 +161,12 @@ Rails/Date:
     - strict
     - flexible
 
+Rails/DefaultScope:
+  Description: 'Avoid use of `default_scope`.'
+  StyleGuide: 'https://rails.rubystyle.guide#avoid-default-scope'
+  Enabled: false
+  VersionAdded: '2.7'
+
 Rails/Delegate:
   Description: 'Prefer delegate method for delegations.'
   Enabled: true
@@ -234,6 +248,14 @@ Rails/FindBy:
   Include:
     - app/models/**/*.rb
 
+Rails/FindById:
+  Description: >-
+                Favor the use of `find` over `where.take!`, `find_by!`, and `find_by_id!` when you
+                need to retrieve a single record by primary key when you expect it to be found.
+  StyleGuide: 'https://rails.rubystyle.guide/#find'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+
 Rails/FindEach:
   Description: 'Prefer all.find_each over all.find.'
   StyleGuide: 'https://rails.rubystyle.guide#find-each'
@@ -300,6 +322,12 @@ Rails/IndexWith:
   Enabled: true
   VersionAdded: '2.5'
 
+Rails/Inquiry:
+  Description: "Prefer Ruby's comparison operators over Active Support's `Array#inquiry` and `String#inquiry`."
+  StyleGuide: 'https://rails.rubystyle.guide/#inquiry'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+
 Rails/InverseOf:
   Description: 'Checks for associations where the inverse cannot be determined automatically.'
   Enabled: true
@@ -325,6 +353,31 @@ Rails/LinkToBlank:
   Enabled: true
   VersionAdded: '0.62'
 
+Rails/MailerName:
+  Description: 'Mailer should end with `Mailer` suffix.'
+  StyleGuide: 'https://rails.rubystyle.guide/#mailer-name'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+  Include:
+    - app/mailers/**/*.rb
+
+Rails/MatchRoute:
+  Description: >-
+                  Don't use `match` to define any routes unless there is a need to map multiple request types
+                  among [:get, :post, :patch, :put, :delete] to a single action using the `:via` option.
+  StyleGuide: 'https://rails.rubystyle.guide/#no-match-routes'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+  Include:
+    - config/routes.rb
+    - config/routes/**/*.rb
+
+Rails/NegateInclude:
+  Description: 'Prefer `collection.exclude?(obj)` over `!collection.include?(obj)`.'
+  StyleGuide: 'https://rails.rubystyle.guide#exclude'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+
 Rails/NotNullColumn:
   Description: 'Do not add a NOT NULL column without a default value.'
   Enabled: true
@@ -350,10 +403,30 @@ Rails/OutputSafety:
 
 Rails/Pick:
   Description: 'Prefer `pick` over `pluck(...).first`.'
+  StyleGuide: 'https://rails.rubystyle.guide#pick'
   Enabled: true
   Safe: false
   VersionAdded: '2.6'
 
+Rails/Pluck:
+  Description: 'Prefer `pluck` over `map { ... }`.'
+  StyleGuide: 'https://rails.rubystyle.guide#pluck'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+
+Rails/PluckId:
+  Description: 'Use `ids` instead of `pluck(:id)` or `pluck(primary_key)`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#ids'
+  Enabled: 'pending'
+  Safe: false
+  VersionAdded: '2.7'
+
+Rails/PluckInWhere:
+  Description: 'Use `select` instead of `pluck` in `where` query methods.'
+  Enabled: 'pending'
+  Safe: false
+  VersionAdded: '2.7'
+
 Rails/PluralizationGrammar:
   Description: 'Checks for incorrect grammar when using methods like `3.day.ago`.'
   Enabled: true
@@ -441,6 +514,20 @@ Rails/RelativeDateConstant:
   VersionChanged: '0.59'
   AutoCorrect: false
 
+Rails/RenderInline:
+  Description: 'Prefer using a template over inline rendering.'
+  StyleGuide: 'https://rails.rubystyle.guide/#inline-rendering'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+
+Rails/RenderPlainText:
+  Description: 'Prefer `render plain:` over `render text:`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#plain-text-rendering'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+  # Convert only when `content_type` is explicitly set to `text/plain`.
+  ContentTypeCompatibility: true
+
 Rails/RequestReferer:
   Description: 'Use consistent syntax for request.referer.'
   Enabled: true
@@ -498,6 +585,16 @@ Rails/ScopeArgs:
   Include:
     - app/models/**/*.rb
 
+Rails/ShortI18n:
+  Description: 'Use the short form of the I18n methods: `t` instead of `translate` and `l` instead of `localize`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#short-i18n'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+  EnforcedStyle: conservative
+  SupportedStyles:
+    - conservative
+    - aggressive
+
 Rails/SkipsModelValidations:
   Description: >-
                  Use methods that skips model validations with caution.
@@ -505,20 +602,27 @@ Rails/SkipsModelValidations:
   Reference: 'https://guides.rubyonrails.org/active_record_validations.html#skipping-validations'
   Enabled: true
   VersionAdded: '0.47'
-  VersionChanged: '0.60'
-  Blacklist:
+  VersionChanged: '2.7'
+  ForbiddenMethods:
     - decrement!
     - decrement_counter
     - increment!
     - increment_counter
+    - insert
+    - insert!
+    - insert_all
+    - insert_all!
     - toggle!
     - touch
+    - touch_all
     - update_all
     - update_attribute
     - update_column
     - update_columns
     - update_counters
-  Whitelist: []
+    - upsert
+    - upsert_all
+  AllowedMethods: []
 
 Rails/TimeZone:
   Description: 'Checks the correct usage of time zone aware methods.'
@@ -570,6 +674,11 @@ Rails/Validation:
   Include:
     - app/models/**/*.rb
 
+Rails/WhereExists:
+  Description: 'Prefer `exists?(...)` over `where(...).exists?`.'
+  Enabled: 'pending'
+  VersionAdded: '2.7'
+
 # Accept `redirect_to(...) and return` and similar cases.
 Style/AndOr:
   EnforcedStyle: conditionals

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

@@ -6,6 +6,8 @@ module RuboCop
     module ActiveRecordHelper
       extend NodePattern::Macros
 
+      WHERE_METHODS = %i[where rewhere].freeze
+
       def_node_search :find_set_table_name, <<~PATTERN
         (send self :table_name= {str sym})
       PATTERN
@@ -72,6 +74,11 @@ module RuboCop
           break pair.value.value.to_s
         end
       end
+
+      def in_where?(node)
+        send_node = node.each_ancestor(:send).first
+        send_node && WHERE_METHODS.include?(send_node.method_name)
+      end
     end
   end
 end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that Active Record callbacks are declared
+      # in the order in which they will be executed.
+      #
+      # @example
+      #   # bad
+      #   class Person < ApplicationRecord
+      #     after_commit :after_commit_callback
+      #     before_validation :before_validation_callback
+      #   end
+      #
+      #   # good
+      #   class Person < ApplicationRecord
+      #     before_validation :before_validation_callback
+      #     after_commit :after_commit_callback
+      #   end
+      #
+      class ActiveRecordCallbacksOrder < Cop
+        MSG = '`%<current>s` is supposed to appear before `%<previous>s`.'
+
+        CALLBACKS_IN_ORDER = %i[
+          after_initialize
+          before_validation
+          after_validation
+          before_save
+          around_save
+          before_create
+          around_create
+          after_create
+          before_update
+          around_update
+          after_update
+          before_destroy
+          around_destroy
+          after_destroy
+          after_save
+          after_commit
+          after_rollback
+          after_find
+          after_touch
+        ].freeze
+
+        CALLBACKS_ORDER_MAP = Hash[
+          CALLBACKS_IN_ORDER.map.with_index { |name, index| [name, index] }
+        ].freeze
+
+        def on_class(class_node)
+          previous_index = -1
+          previous_callback = nil
+
+          defined_callbacks(class_node).each do |node|
+            callback = node.method_name
+            index = CALLBACKS_ORDER_MAP[callback]
+
+            if index < previous_index
+              message = format(MSG, current: callback,
+                                    previous: previous_callback)
+              add_offense(node, message: message)
+            end
+            previous_index = index
+            previous_callback = callback
+          end
+        end
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(node)
+          previous = left_siblings_of(node).find do |sibling|
+            callback?(sibling)
+          end
+
+          current_range = source_range_with_comment(node)
+          previous_range = source_range_with_comment(previous)
+
+          lambda do |corrector|
+            corrector.insert_before(previous_range, current_range.source)
+            corrector.remove(current_range)
+          end
+        end
+
+        private
+
+        def defined_callbacks(class_node)
+          class_def = class_node.body
+
+          if class_def
+            class_def.each_child_node.select { |c| callback?(c) }
+          else
+            []
+          end
+        end
+
+        def callback?(node)
+          node.send_type? && CALLBACKS_ORDER_MAP.key?(node.method_name)
+        end
+
+        def left_siblings_of(node)
+          siblings_of(node)[0, node.sibling_index]
+        end
+
+        def siblings_of(node)
+          node.parent.children
+        end
+
+        def source_range_with_comment(node)
+          begin_pos = begin_pos_with_comment(node)
+          end_pos = end_position_for(node)
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def end_position_for(node)
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          buffer.line_range(end_line).end_pos
+        end
+
+        def begin_pos_with_comment(node)
+          annotation_line = node.first_line - 1
+          first_comment = nil
+
+          processed_source.comments_before_line(annotation_line)
+                          .reverse_each do |comment|
+            if comment.location.line == annotation_line
+              first_comment = comment
+              annotation_line -= 1
+            end
+          end
+
+          start_line_position(first_comment || node)
+        end
+
+        def start_line_position(node)
+          buffer.line_range(node.loc.line).begin_pos - 1
+        end
+
+        def buffer
+          processed_source.buffer
+        end
+      end
+    end
+  end
+end

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

@@ -40,8 +40,12 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             if method_name?(node.first_argument)
-              replace_method_with_tag_method(corrector, node)
-              remove_first_argument(corrector, node)
+              range = correction_range(node)
+
+              rest_args = node.arguments.drop(1)
+              replacement = "tag.#{node.first_argument.value}(#{rest_args.map(&:source).join(', ')})"
+
+              corrector.replace(range, replacement)
             else
               corrector.replace(node.loc.selector, 'tag')
             end
@@ -56,25 +60,8 @@ module RuboCop
           /^[a-zA-Z_][a-zA-Z_0-9]*$/.match?(node.value)
         end
 
-        def replace_method_with_tag_method(corrector, node)
-          corrector.replace(
-            node.loc.selector,
-            "tag.#{node.first_argument.value}"
-          )
-        end
-
-        def remove_first_argument(corrector, node)
-          if node.arguments.length > 1
-            corrector.remove(
-              range_between(child_node_beg(node, 0), child_node_beg(node, 1))
-            )
-          elsif node.arguments.length == 1
-            corrector.remove(node.arguments[0].loc.expression)
-          end
-        end
-
-        def child_node_beg(node, index)
-          node.arguments[index].loc.expression.begin_pos
+        def correction_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
       end
     end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `default_scope`.
+      #
+      # @example
+      #   # bad
+      #   default_scope -> { where(hidden: false) }
+      #
+      #   # good
+      #   scope :published, -> { where(hidden: false) }
+      #
+      #   # bad
+      #   def self.default_scope
+      #     where(hidden: false)
+      #   end
+      #
+      #   # good
+      #   def self.published
+      #     where(hidden: false)
+      #   end
+      #
+      class DefaultScope < Cop
+        MSG = 'Avoid use of `default_scope`. It is better to use explicitly named scopes.'
+
+        def_node_matcher :method_call?, <<~PATTERN
+          (send nil? :default_scope ...)
+        PATTERN
+
+        def_node_matcher :class_method_definition?, <<~PATTERN
+          (defs _ :default_scope args ...)
+        PATTERN
+
+        def_node_matcher :eigenclass_method_definition?, <<~PATTERN
+          (sclass (self) $(def :default_scope args ...))
+        PATTERN
+
+        def on_send(node)
+          add_offense(node, location: :selector) if method_call?(node)
+        end
+
+        def on_defs(node)
+          add_offense(node, location: :name) if class_method_definition?(node)
+        end
+
+        def on_sclass(node)
+          eigenclass_method_definition?(node) { |default_scope| add_offense(default_scope, location: :name) }
+        end
+      end
+    end
+  end
+end