rubocop-rails 2.8.0 → 2.10.1

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

@@ -20,8 +20,11 @@ module RuboCop
       #   match 'photos/:id', to: 'photos#show', via: [:get, :post]
       #   match 'photos/:id', to: 'photos#show', via: :all
       #
-      class MatchRoute < Cop
+      class MatchRoute < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<http_method>s` instead of `match` to define a route.'
+        RESTRICT_ON_SEND = %i[match].freeze
         HTTP_METHODS = %i[get post put patch delete].freeze
 
         def_node_matcher :match_method_call?, <<~PATTERN
@@ -35,30 +38,28 @@ module RuboCop
             options_node = path_node.hash_type? ? path_node : options_node.first
 
             if options_node.nil?
-              message = format(MSG, http_method: 'get')
-              add_offense(node, message: message)
+              register_offense(node, 'get')
             else
               via = extract_via(options_node)
-              if via.size == 1 && http_method?(via.first)
-                message = format(MSG, http_method: via.first)
-                add_offense(node, message: message)
-              end
+              return unless via.size == 1 && http_method?(via.first)
+
+              register_offense(node, via.first)
             end
           end
         end
 
-        def autocorrect(node)
-          match_method_call?(node) do |path_node, options_node|
-            options_node = options_node.first
+        private
+
+        def register_offense(node, http_method)
+          add_offense(node, message: format(MSG, http_method: http_method)) do |corrector|
+            match_method_call?(node) do |path_node, options_node|
+              options_node = options_node.first
 
-            lambda do |corrector|
               corrector.replace(node, replacement(path_node, options_node))
             end
           end
         end
 
-        private
-
         def_node_matcher :routes_draw?, <<~PATTERN
           (send (send _ :routes) :draw)
         PATTERN

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop enforces the use of `collection.exclude?(obj)`
       # over `!collection.include?(obj)`.
       #
+      # It is marked as unsafe by default because false positive will occur for
+      # a receiver object that do not have `exclude?` method. (e.g. `IPAddr`)
+      #
       # @example
       #   # bad
       #   !array.include?(2)
@@ -15,22 +18,21 @@ module RuboCop
       #   array.exclude?(2)
       #   hash.exclude?(:key)
       #
-      class NegateInclude < Cop
+      class NegateInclude < Base
+        extend AutoCorrector
+
         MSG = 'Use `.exclude?` and remove the negation part.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :negate_include_call?, <<~PATTERN
           (send (send $_ :include? $_) :!)
         PATTERN
 
         def on_send(node)
-          add_offense(node) if negate_include_call?(node)
-        end
+          return unless (receiver, obj = negate_include_call?(node))
 
-        def autocorrect(node)
-          negate_include_call?(node) do |receiver, obj|
-            lambda do |corrector|
-              corrector.replace(node, "#{receiver.source}.exclude?(#{obj.source})")
-            end
+          add_offense(node) do |corrector|
+            corrector.replace(node, "#{receiver.source}.exclude?(#{obj.source})")
           end
         end
       end

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

@@ -16,8 +16,9 @@ module RuboCop
       #   add_column :users, :name, :string, null: false, default: ''
       #   add_reference :products, :category
       #   add_reference :products, :category, null: false, default: 1
-      class NotNullColumn < Cop
+      class NotNullColumn < Base
         MSG = 'Do not add a NOT NULL column without a default value.'
+        RESTRICT_ON_SEND = %i[add_column add_reference].freeze
 
         def_node_matcher :add_not_null_column?, <<~PATTERN
           (send nil? :add_column _ _ _ (hash $...))

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

@@ -25,6 +25,7 @@ module RuboCop
 
         MSG = 'Do not use the `id` column for ordering. '\
               'Use a timestamp column to order chronologically.'
+        RESTRICT_ON_SEND = %i[order].freeze
 
         def_node_matcher :order_by_id?, <<~PATTERN
           (send _ :order
@@ -37,8 +38,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:order)
-
           add_offense(offense_range(node)) if order_by_id?(node)
         end
 

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

@@ -13,9 +13,12 @@ module RuboCop
       #
       #   # good
       #   Rails.logger.debug 'A debug message'
-      class Output < Cop
+      class Output < Base
         MSG = 'Do not write to stdout. ' \
               "Use Rails's logger if you want to log."
+        RESTRICT_ON_SEND = %i[
+          ap p pp pretty_print print puts binwrite syswrite write write_nonblock
+        ].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
@@ -35,7 +38,7 @@ module RuboCop
           return unless (output?(node) || io_output?(node)) &&
                         node.arguments?
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
 
         private

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

@@ -62,8 +62,9 @@ module RuboCop
       #   safe_join([user_content, " ", content_tag(:span, user_content)])
       #   # => ActiveSupport::SafeBuffer
       #   #    "&lt;b&gt;hi&lt;/b&gt; <span>&lt;b&gt;hi&lt;/b&gt;</span>"
-      class OutputSafety < Cop
+      class OutputSafety < Base
         MSG = 'Tagging a string as html safe may be a security risk.'
+        RESTRICT_ON_SEND = %i[html_safe raw safe_concat].freeze
 
         def on_send(node)
           return if non_interpolated_string?(node)
@@ -72,7 +73,7 @@ module RuboCop
                         looks_like_rails_raw?(node) ||
                         looks_like_rails_safe_concat?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
         alias on_csend on_send
 

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

@@ -17,10 +17,12 @@ module RuboCop
       #   # good
       #   Model.pick(:a)
       #   [{ a: :b, c: :d }].pick(:a, :b)
-      class Pick < Cop
+      class Pick < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         MSG = 'Prefer `pick(%<args>s)` over `pluck(%<args>s).first`.'
+        RESTRICT_ON_SEND = %i[first].freeze
 
         minimum_target_rails_version 6.0
 
@@ -30,24 +32,24 @@ module RuboCop
 
         def on_send(node)
           pick_candidate?(node) do
-            range = node.receiver.loc.selector.join(node.loc.selector)
-            add_offense(node, location: range)
-          end
-        end
+            receiver = node.receiver
+            receiver_selector = receiver.loc.selector
+            node_selector = node.loc.selector
+            range = receiver_selector.join(node_selector)
 
-        def autocorrect(node)
-          first_range = node.receiver.source_range.end.join(node.loc.selector)
+            add_offense(range, message: message(receiver)) do |corrector|
+              first_range = receiver.source_range.end.join(node_selector)
 
-          lambda do |corrector|
-            corrector.remove(first_range)
-            corrector.replace(node.receiver.loc.selector, 'pick')
+              corrector.remove(first_range)
+              corrector.replace(receiver_selector, 'pick')
+            end
           end
         end
 
         private
 
-        def message(node)
-          format(MSG, args: node.receiver.arguments.map(&:source).join(', '))
+        def message(receiver)
+          format(MSG, args: receiver.arguments.map(&:source).join(', '))
         end
       end
     end

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

@@ -17,7 +17,8 @@ module RuboCop
       #   # good
       #   Post.published.pluck(:title)
       #   [{ a: :b, c: :d }].pluck(:a)
-      class Pluck < Cop
+      class Pluck < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         MSG = 'Prefer `pluck(:%<value>s)` over `%<method>s { |%<argument>s| %<element>s[:%<value>s] }`.'
@@ -32,15 +33,11 @@ module RuboCop
           pluck_candidate?(node) do |method, argument, element, value|
             next unless argument == element
 
-            add_offense(node, location: offense_range(node), message: message(method, argument, element, value))
-          end
-        end
-
-        def autocorrect(node)
-          _method, _argument, _element, value = pluck_candidate?(node)
+            message = message(method, argument, element, value)
 
-          lambda do |corrector|
-            corrector.replace(offense_range(node), "pluck(:#{value})")
+            add_offense(offense_range(node), message: message) do |corrector|
+              corrector.replace(offense_range(node), "pluck(:#{value})")
+            end
           end
         end
 

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

@@ -22,11 +22,13 @@ module RuboCop
       #     ids
       #   end
       #
-      class PluckId < Cop
+      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)})
@@ -38,11 +40,7 @@ module RuboCop
           range = offense_range(node)
           message = format(MSG, bad_method: range.source)
 
-          add_offense(node, location: range, message: message)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(range, message: message) do |corrector|
             corrector.replace(offense_range(node), 'ids')
           end
         end

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

@@ -34,22 +34,22 @@ module RuboCop
       #   # bad
       #   Post.where(user_id: active_users.pluck(:id))
       #
-      class PluckInWhere < Cop
+      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 node.method?(:pluck) && in_where?(node)
+          return unless in_where?(node)
           return if style == :conservative && !root_receiver(node)&.const_type?
 
-          add_offense(node, location: :selector)
-        end
+          range = node.loc.selector
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'select')
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'select')
           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