rubocop-rails 2.6.0 → 2.9.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `ids` over `pluck(:id)` and `pluck(primary_key)`.
+      #
+      # @example
+      #   # bad
+      #   User.pluck(:id)
+      #   user.posts.pluck(:id)
+      #
+      #   def self.user_ids
+      #     pluck(primary_key)
+      #   end
+      #
+      #   # good
+      #   User.ids
+      #   user.posts.ids
+      #
+      #   def self.user_ids
+      #     ids
+      #   end
+      #
+      class PluckId < Base
+        include RangeHelp
+        include ActiveRecordHelper
+        extend AutoCorrector
+
+        MSG = 'Use `ids` instead of `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[pluck].freeze
+
+        def_node_matcher :pluck_id_call?, <<~PATTERN
+          (send _ :pluck {(sym :id) (send nil? :primary_key)})
+        PATTERN
+
+        def on_send(node)
+          return if !pluck_id_call?(node) || in_where?(node)
+
+          range = offense_range(node)
+          message = format(MSG, bad_method: range.source)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(offense_range(node), 'ids')
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where `pluck` is used in `where` query methods
+      # and can be replaced with `select`.
+      #
+      # 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 < Base
+        include ActiveRecordHelper
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Use `select` instead of `pluck` within `where` query method.'
+        RESTRICT_ON_SEND = %i[pluck].freeze
+
+        def on_send(node)
+          return unless in_where?(node)
+          return if style == :conservative && !root_receiver(node)&.const_type?
+
+          range = node.loc.selector
+
+          add_offense(range) do |corrector|
+            corrector.replace(range, '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
+end

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

@@ -14,7 +14,9 @@ module RuboCop
       #   # good
       #   3.days.ago
       #   1.month.ago
-      class PluralizationGrammar < Cop
+      class PluralizationGrammar < Base
+        extend AutoCorrector
+
         SINGULAR_DURATION_METHODS = { second: :seconds,
                                       minute: :minutes,
                                       hour: :hours,
@@ -24,21 +26,18 @@ module RuboCop
                                       month: :months,
                                       year: :years }.freeze
 
+        RESTRICT_ON_SEND = SINGULAR_DURATION_METHODS.keys + SINGULAR_DURATION_METHODS.values
+
         PLURAL_DURATION_METHODS = SINGULAR_DURATION_METHODS.invert.freeze
 
         MSG = 'Prefer `%<number>s.%<correct>s`.'
 
         def on_send(node)
-          return unless duration_method?(node.method_name)
-          return unless literal_number?(node.receiver)
+          return unless duration_method?(node.method_name) && literal_number?(node.receiver) && offense?(node)
 
-          return unless offense?(node)
-
-          add_offense(node)
-        end
+          number, = *node.receiver
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message(number, node.method_name)) do |corrector|
             method_name = node.loc.selector.source
 
             corrector.replace(node.loc.selector, correct_method(method_name))
@@ -47,11 +46,8 @@ module RuboCop
 
         private
 
-        def message(node)
-          number, = *node.receiver
-
-          format(MSG, number: number,
-                      correct: correct_method(node.method_name.to_s))
+        def message(number, method_name)
+          format(MSG, number: number, correct: correct_method(method_name))
         end
 
         def correct_method(method_name)

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

@@ -37,8 +37,9 @@ module RuboCop
       #
       #   # good
       #   a.presence || b
-      class Presence < Cop
+      class Presence < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -76,28 +77,26 @@ module RuboCop
           return if ignore_if_node?(node)
 
           redundant_receiver_and_other(node) do |receiver, other|
-            add_offense(node, message: message(node, receiver, other)) unless ignore_other_node?(other) || receiver.nil?
+            return if ignore_other_node?(other) || receiver.nil?
+
+            register_offense(node, receiver, other)
           end
 
           redundant_negative_receiver_and_other(node) do |receiver, other|
-            add_offense(node, message: message(node, receiver, other)) unless ignore_other_node?(other) || receiver.nil?
+            return if ignore_other_node?(other) || receiver.nil?
+
+            register_offense(node, receiver, other)
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            redundant_receiver_and_other(node) do |receiver, other|
-              corrector.replace(node.source_range, replacement(receiver, other))
-            end
+        private
 
-            redundant_negative_receiver_and_other(node) do |receiver, other|
-              corrector.replace(node.source_range, replacement(receiver, other))
-            end
+        def register_offense(node, receiver, other)
+          add_offense(node, message: message(node, receiver, other)) do |corrector|
+            corrector.replace(node.source_range, replacement(receiver, other))
           end
         end
 
-        private
-
         def ignore_if_node?(node)
           node.elsif?
         end

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

@@ -43,12 +43,15 @@ module RuboCop
       #
       #   # good
       #   something if foo.present?
-      class Present < Cop
+      class Present < Base
+        extend AutoCorrector
+
         MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'
         MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
                                    '`%<current>s`.'
         MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
                            '`%<current>s`.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :exists_and_not_empty?, <<~PATTERN
           (and
@@ -74,10 +77,11 @@ module RuboCop
           return unless cop_config['NotBlank']
 
           not_blank?(node) do |receiver|
-            add_offense(node,
-                        message: format(MSG_NOT_BLANK,
-                                        prefer: replacement(receiver),
-                                        current: node.source))
+            message = format(MSG_NOT_BLANK, prefer: replacement(receiver), current: node.source)
+
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -87,10 +91,11 @@ module RuboCop
           exists_and_not_empty?(node) do |var1, var2|
             return unless var1 == var2
 
-            add_offense(node,
-                        message: format(MSG_EXISTS_AND_NOT_EMPTY,
-                                        prefer: replacement(var1),
-                                        current: node.source))
+            message = format(MSG_EXISTS_AND_NOT_EMPTY, prefer: replacement(var1), current: node.source)
+
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -100,7 +105,9 @@ module RuboCop
           exists_and_not_empty?(node) do |var1, var2|
             return unless var1 == var2
 
-            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
+            add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -113,25 +120,24 @@ module RuboCop
             range = unless_condition(node, method_call)
             msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
                                            current: range.source)
-            add_offense(node, location: range, message: msg)
+            add_offense(range, message: msg) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            method_call, variable1 = unless_blank?(node)
-
-            if method_call
-              corrector.replace(node.loc.keyword, 'if')
-              range = method_call.loc.expression
-            else
-              variable1, _variable2 =
-                exists_and_not_empty?(node) || not_blank?(node)
-              range = node.loc.expression
-            end
+        def autocorrect(corrector, node)
+          method_call, variable1 = unless_blank?(node)
 
-            corrector.replace(range, replacement(variable1))
+          if method_call
+            corrector.replace(node.loc.keyword, 'if')
+            range = method_call.loc.expression
+          else
+            variable1, _variable2 = exists_and_not_empty?(node) || not_blank?(node)
+            range = node.loc.expression
           end
+
+          corrector.replace(range, replacement(variable1))
         end
 
         private

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

@@ -25,7 +25,9 @@ module RuboCop
       #     do_something
       #   end
       #
-      class RakeEnvironment < Cop
+      class RakeEnvironment < Base
+        extend AutoCorrector
+
         MSG = 'Include `:environment` task as a dependency for all Rake tasks.'
 
         def_node_matcher :task_definition?, <<~PATTERN
@@ -37,16 +39,12 @@ module RuboCop
             return if task_name(task_method) == :default
             return if with_dependencies?(task_method)
 
-            add_offense(task_method)
-          end
-        end
+            add_offense(task_method) do |corrector|
+              task_name = task_method.arguments[0]
+              task_dependency = correct_task_dependency(task_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            task_name = node.arguments[0]
-            task_dependency = correct_task_dependency(task_name)
-
-            corrector.replace(task_name.loc.expression, task_dependency)
+              corrector.replace(task_name.loc.expression, task_dependency)
+            end
           end
         end
 
@@ -54,7 +52,7 @@ module RuboCop
 
         def correct_task_dependency(task_name)
           if task_name.sym_type?
-            task_name.source.delete(':|\'|"') + ': :environment'
+            "#{task_name.source.delete(':|\'|"')}: :environment"
           else
             "#{task_name.source} => :environment"
           end

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

@@ -23,8 +23,11 @@ module RuboCop
       #   # good
       #   x = self[:attr]
       #   self[:attr] = val
-      class ReadWriteAttribute < Cop
+      class ReadWriteAttribute < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[read_attribute write_attribute].freeze
 
         def_node_matcher :read_write_attribute?, <<~PATTERN
           {
@@ -36,18 +39,16 @@ module RuboCop
         def on_send(node)
           return unless read_write_attribute?(node)
 
-          add_offense(node, location: :selector)
-        end
+          add_offense(node.loc.selector, message: message(node)) do |corrector|
+            case node.method_name
+            when :read_attribute
+              replacement = read_attribute_replacement(node)
+            when :write_attribute
+              replacement = write_attribute_replacement(node)
+            end
 
-        def autocorrect(node)
-          case node.method_name
-          when :read_attribute
-            replacement = read_attribute_replacement(node)
-          when :write_attribute
-            replacement = write_attribute_replacement(node)
+            corrector.replace(node.source_range, replacement)
           end
-
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         private

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

@@ -26,8 +26,9 @@ module RuboCop
       #   # Here, `nil` is valid but `''` is not
       #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
       #
-      class RedundantAllowNil < Cop
+      class RedundantAllowNil < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_SAME =
           '`allow_nil` is redundant when `allow_blank` has the same value.'
@@ -35,59 +36,56 @@ module RuboCop
         MSG_ALLOW_NIL_FALSE =
           '`allow_nil: false` is redundant when `allow_blank` is true.'
 
-        def on_send(node)
-          return unless node.method?(:validates)
+        RESTRICT_ON_SEND = %i[validates].freeze
 
+        def on_send(node)
           allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
           return unless allow_nil && allow_blank
 
           allow_nil_val = allow_nil.children.last
           allow_blank_val = allow_blank.children.last
 
-          offense(allow_nil_val, allow_blank_val, allow_nil)
+          if allow_nil_val.type == allow_blank_val.type
+            register_offense(allow_nil, MSG_SAME)
+          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
+            register_offense(allow_nil, MSG_ALLOW_NIL_FALSE)
+          end
         end
 
-        def autocorrect(node)
-          prv_sib = previous_sibling(node)
-          nxt_sib = next_sibling(node)
+        private
+
+        def register_offense(allow_nil, message)
+          add_offense(allow_nil, message: message) do |corrector|
+            prv_sib = previous_sibling(allow_nil)
+            nxt_sib = next_sibling(allow_nil)
 
-          lambda do |corrector|
             if nxt_sib
-              corrector.remove(range_between(node_beg(node), node_beg(nxt_sib)))
+              corrector.remove(range_between(node_beg(allow_nil), node_beg(nxt_sib)))
             elsif prv_sib
-              corrector.remove(range_between(node_end(prv_sib), node_end(node)))
+              corrector.remove(range_between(node_end(prv_sib), node_end(allow_nil)))
             else
-              corrector.remove(node.loc.expression)
+              corrector.remove(allow_nil.loc.expression)
             end
           end
         end
 
-        private
-
-        def offense(allow_nil_val, allow_blank_val, allow_nil)
-          if allow_nil_val.type == allow_blank_val.type
-            add_offense(allow_nil, message: MSG_SAME)
-          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
-            add_offense(allow_nil, message: MSG_ALLOW_NIL_FALSE)
-          end
-        end
-
         def find_allow_nil_and_allow_blank(node)
-          allow_nil = nil
-          allow_blank = nil
+          allow_nil, allow_blank = nil
 
-          node.each_descendant do |descendant|
-            next unless descendant.pair_type?
+          node.each_child_node do |child_node|
+            if child_node.pair_type?
+              key = child_node.children.first.source
 
-            key = descendant.children.first.source
-
-            allow_nil = descendant if key == 'allow_nil'
-            allow_blank = descendant if key == 'allow_blank'
+              allow_nil = child_node if key == 'allow_nil'
+              allow_blank = child_node if key == 'allow_blank'
+            end
+            return [allow_nil, allow_blank] if allow_nil && allow_blank
 
-            break if allow_nil && allow_blank
+            found_in_children_nodes = find_allow_nil_and_allow_blank(child_node)
+            return found_in_children_nodes if found_in_children_nodes
           end
 
-          [allow_nil, allow_blank]
+          nil
         end
 
         def previous_sibling(node)