rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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.
+      #
+      # @safety
+      #   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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for correct grammar when using ActiveSupport's
+      # Checks for correct grammar when using ActiveSupport's
       # core extensions to the numeric classes.
       #
       # @example
@@ -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)
@@ -65,8 +61,8 @@ module RuboCop
         def offense?(node)
           number, = *node.receiver
 
-          singular_receiver?(number) && plural_method?(node.method_name) ||
-            plural_receiver?(number) && singular_method?(node.method_name)
+          (singular_receiver?(number) && plural_method?(node.method_name)) ||
+            (plural_receiver?(number) && singular_method?(node.method_name))
         end
 
         def plural_method?(method_name)
@@ -98,8 +94,7 @@ module RuboCop
         end
 
         def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) ||
-            PLURAL_DURATION_METHODS.key?(method_name)
+          SINGULAR_DURATION_METHODS.key?(method_name) || PLURAL_DURATION_METHODS.key?(method_name)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks code that can be written more easily using
+      # Checks code that can be written more easily using
       # `Object#presence` defined by Active Support.
       #
       # @example
@@ -37,10 +37,13 @@ module RuboCop
       #
       #   # good
       #   a.presence || b
-      class Presence < Cop
+      class Presence < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
-        def_node_matcher :redundant_receiver_and_other, <<-PATTERN
+        def_node_matcher :redundant_receiver_and_other, <<~PATTERN
           {
             (if
               (send $_recv :present?)
@@ -55,7 +58,7 @@ module RuboCop
           }
         PATTERN
 
-        def_node_matcher :redundant_negative_receiver_and_other, <<-PATTERN
+        def_node_matcher :redundant_negative_receiver_and_other, <<~PATTERN
           {
             (if
               (send (send $_recv :present?) :!)
@@ -74,32 +77,26 @@ module RuboCop
           return if ignore_if_node?(node)
 
           redundant_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
+            return if ignore_other_node?(other) || receiver.nil?
+
+            register_offense(node, receiver, other)
           end
 
           redundant_negative_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
+            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, replacement(receiver, other, node.left_sibling))
           end
         end
 
-        private
-
         def ignore_if_node?(node)
           node.elsif?
         end
@@ -109,14 +106,45 @@ module RuboCop
         end
 
         def message(node, receiver, other)
-          format(MSG,
-                 prefer: replacement(receiver, other),
-                 current: node.source)
+          prefer = replacement(receiver, other, node.left_sibling).gsub(/^\s*|\n/, '')
+          current = current(node).gsub(/^\s*|\n/, '')
+          format(MSG, prefer: prefer, current: current)
+        end
+
+        def current(node)
+          if !node.ternary? && node.source.include?("\n")
+            "#{node.loc.keyword.with(end_pos: node.condition.loc.selector.end_pos).source} ... end"
+          else
+            node.source.gsub(/\n\s*/, ' ')
+          end
+        end
+
+        def replacement(receiver, other, left_sibling)
+          or_source = if other&.send_type?
+                        build_source_for_or_method(other)
+                      elsif other.nil? || other.nil_type?
+                        ''
+                      else
+                        " || #{other.source}"
+                      end
+
+          replaced = "#{receiver.source}.presence#{or_source}"
+          left_sibling ? "(#{replaced})" : replaced
+        end
+
+        def build_source_for_or_method(other)
+          if other.parenthesized? || other.method?('[]') || other.arithmetic_operation? || !other.arguments?
+            " || #{other.source}"
+          else
+            method = method_range(other).source
+            arguments = other.arguments.map(&:source).join(', ')
+
+            " || #{method}(#{arguments})"
+          end
         end
 
-        def replacement(receiver, other)
-          or_source = other.nil? || other.nil_type? ? '' : " || #{other.source}"
-          "#{receiver.source}.presence" + or_source
+        def method_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos - 1)
         end
       end
     end

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

@@ -3,13 +3,13 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for code that can be written with simpler conditionals
+      # Checks for code that can be written with simpler conditionals
       # using `Object#present?` defined by Active Support.
       #
       # Interaction with `Style/UnlessElse`:
       # The configuration of `NotBlank` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
-      # to prevent interference between the auto-correction of the two cops.
+      # context of `unless else` if `Style/UnlessElse` is enabled. This is
+      # to prevent interference between the autocorrection of the two cops.
       #
       # @example NotNilAndNotEmpty: true (default)
       #   # Converts usages of `!nil? && !empty?` to `present?`
@@ -43,14 +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`.'
+        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
+        def_node_matcher :exists_and_not_empty?, <<~PATTERN
           (and
               {
                 (send (send $_ :nil?) :!)
@@ -66,7 +67,7 @@ module RuboCop
 
         def_node_matcher :not_blank?, '(send (send $_ :blank?) :!)'
 
-        def_node_matcher :unless_blank?, <<-PATTERN
+        def_node_matcher :unless_blank?, <<~PATTERN
           (:if $(send $_ :blank?) {nil? (...)} ...)
         PATTERN
 
@@ -74,10 +75,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 +89,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 +103,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
 
@@ -111,36 +116,34 @@ module RuboCop
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
-                                           current: range.source)
-            add_offense(node, location: range, message: msg)
+            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver), current: range.source)
+            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.source_range
+          else
+            variable1, _variable2 = exists_and_not_empty?(node) || not_blank?(node)
+            range = node.source_range
           end
+
+          corrector.replace(range, replacement(variable1))
         end
 
         private
 
         def unless_condition(node, method_call)
           if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
+            node.loc.keyword.join(node.source_range.end)
           else
-            node.loc.expression.begin.join(method_call.loc.expression)
+            node.source_range.begin.join(method_call.source_range)
           end
         end
 

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for Rake tasks without the `:environment` task
+      # dependency. The `:environment` task loads application code for other
+      # Rake tasks. Without it, tasks cannot make use of application code like
+      # models.
+      #
+      # You can ignore the offense if the task satisfies at least one of the
+      # following conditions:
+      #
+      # * The task does not need application code.
+      # * The task invokes the `:environment` task.
+      #
+      # @safety
+      #   Probably not a problem in most cases, but it is possible that calling `:environment` task
+      #   will break a behavior. It's also slower. E.g. some task that only needs one gem to be
+      #   loaded to run will run significantly faster without loading the whole application.
+      #
+      # @example
+      #   # bad
+      #   task :foo do
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   task foo: :environment do
+      #     do_something
+      #   end
+      #
+      class RakeEnvironment < Base
+        extend AutoCorrector
+
+        MSG = 'Include `:environment` task as a dependency for all Rake tasks.'
+
+        def_node_matcher :task_definition?, <<~PATTERN
+          (block $(send nil? :task ...) ...)
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          task_definition?(node) do |task_method|
+            return if task_name(task_method) == :default
+            return if with_dependencies?(task_method)
+
+            add_offense(task_method) do |corrector|
+              task_name = task_method.arguments[0]
+              task_dependency = correct_task_dependency(task_name)
+
+              corrector.replace(task_name, task_dependency)
+            end
+          end
+        end
+
+        private
+
+        def correct_task_dependency(task_name)
+          if task_name.sym_type?
+            "#{task_name.source.delete(':|\'|"')}: :environment"
+          else
+            "#{task_name.source} => :environment"
+          end
+        end
+
+        def task_name(node)
+          first_arg = node.arguments[0]
+          case first_arg&.type
+          when :sym, :str
+            first_arg.value.to_sym
+          when :hash
+            return nil if first_arg.children.size != 1
+
+            pair = first_arg.children.first
+            key = pair.children.first
+            case key.type
+            when :sym, :str
+              key.value.to_sym
+            end
+          end
+        end
+
+        def with_dependencies?(node)
+          first_arg = node.arguments[0]
+          return false unless first_arg
+
+          if first_arg.hash_type?
+            with_hash_style_dependencies?(first_arg)
+          else
+            task_args = node.arguments[1]
+            return false unless task_args
+            return false unless task_args.hash_type?
+
+            with_hash_style_dependencies?(task_args)
+          end
+        end
+
+        def with_hash_style_dependencies?(hash_node)
+          deps = hash_node.pairs.first&.value
+          return false unless deps
+
+          case deps.type
+          when :array
+            !deps.values.empty?
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of the `read_attribute` or `write_attribute`
+      # Checks for the use of the `read_attribute` or `write_attribute`
       # methods and recommends square brackets instead.
       #
       # If an attribute is missing from the instance (for example, when
@@ -23,10 +23,24 @@ module RuboCop
       #   # good
       #   x = self[:attr]
       #   self[:attr] = val
-      class ReadWriteAttribute < Cop
-        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+      #
+      # When called from within a method with the same name as the attribute,
+      # `read_attribute` and `write_attribute` must be used to prevent an
+      # infinite loop:
+      #
+      # @example
+      #
+      #   # good
+      #   def foo
+      #     bar || read_attribute(:foo)
+      #   end
+      class ReadWriteAttribute < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s`.'
+        RESTRICT_ON_SEND = %i[read_attribute write_attribute].freeze
 
-        def_node_matcher :read_write_attribute?, <<-PATTERN
+        def_node_matcher :read_write_attribute?, <<~PATTERN
           {
             (send nil? :read_attribute _)
             (send nil? :write_attribute _ _)
@@ -35,29 +49,53 @@ module RuboCop
 
         def on_send(node)
           return unless read_write_attribute?(node)
+          return if within_shadowing_method?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node, message: build_message(node)) do |corrector|
+            corrector.replace(node, node_replacement(node))
+          end
         end
 
-        def autocorrect(node)
-          case node.method_name
-          when :read_attribute
-            replacement = read_attribute_replacement(node)
-          when :write_attribute
-            replacement = write_attribute_replacement(node)
-          end
+        private
+
+        def within_shadowing_method?(node)
+          first_arg = node.first_argument
+          return false unless first_arg.respond_to?(:value)
 
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          enclosing_method = node.each_ancestor(:def).first
+          return false unless enclosing_method
+
+          shadowing_method_name = first_arg.value.to_s
+          shadowing_method_name << '=' if node.method?(:write_attribute)
+          enclosing_method.method?(shadowing_method_name)
         end
 
-        private
+        def build_message(node)
+          if node.single_line?
+            single_line_message(node)
+          else
+            multi_line_message(node)
+          end
+        end
+
+        def single_line_message(node)
+          format(MSG, prefer: node_replacement(node))
+        end
 
-        def message(node)
+        def multi_line_message(node)
           if node.method?(:read_attribute)
-            format(MSG, prefer: 'self[:attr]', current: 'read_attribute(:attr)')
+            format(MSG, prefer: 'self[:attr]')
           else
-            format(MSG, prefer: 'self[:attr] = val',
-                        current: 'write_attribute(:attr, val)')
+            format(MSG, prefer: 'self[:attr] = val')
+          end
+        end
+
+        def node_replacement(node)
+          case node.method_name
+          when :read_attribute
+            read_attribute_replacement(node)
+          when :write_attribute
+            write_attribute_replacement(node)
           end
         end