rubocop-rails 2.7.0 → 2.9.1

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

@@ -31,8 +31,11 @@ module RuboCop
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #
-      class HttpStatus < Cop
+      class HttpStatus < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[render redirect_to].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
@@ -53,14 +56,9 @@ module RuboCop
             checker = checker_class.new(status)
             return unless checker.offensive?
 
-            add_offense(checker.node, message: checker.message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            checker = checker_class.new(node)
-            corrector.replace(node.loc.expression, checker.preferred_style)
+            add_offense(checker.node, message: checker.message) do |corrector|
+              corrector.replace(checker.node.loc.expression, checker.preferred_style)
+            end
           end
         end
 

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

@@ -37,18 +37,20 @@ module RuboCop
       #   end
       #
       # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
-      class IgnoredSkipActionFilterOption < Cop
+      class IgnoredSkipActionFilterOption < Base
         MSG = <<~MSG.chomp.freeze
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
         MSG
 
-        FILTERS = %w[
-          :skip_after_action
-          :skip_around_action
-          :skip_before_action
-          :skip_action_callback
+        RESTRICT_ON_SEND = %i[
+          skip_after_action
+          skip_around_action
+          skip_before_action
+          skip_action_callback
         ].freeze
 
+        FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
+
         def_node_matcher :filter_options, <<~PATTERN
           (send
             nil?

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

@@ -11,19 +11,28 @@ 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] }]
       #
       #   # good
       #   [1, 2, 3].index_by { |el| foo(el) }
-      class IndexBy < Cop
+      class IndexBy < Base
         include IndexMethod
+        extend AutoCorrector
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= $_ (lvar _el)))
+            ({send csend} (lvar _memo) :[]= $!`_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

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

@@ -11,12 +11,14 @@ 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)] }]
       #
       #   # good
       #   [1, 2, 3].index_with { |el| foo(el) }
-      class IndexWith < Cop
+      class IndexWith < Base
+        extend AutoCorrector
         extend TargetRailsVersion
         include IndexMethod
 
@@ -26,7 +28,14 @@ module RuboCop
           (block
             ({send csend} _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= (lvar _el) $_))
+            ({send csend} (lvar _memo) :[]= (lvar _el) $!`_memo))
+        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

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

@@ -22,11 +22,16 @@ module RuboCop
       #   pets = %w(cat dog)
       #   pets.include? 'cat'
       #
-      class Inquiry < Cop
+      class Inquiry < Base
         MSG = "Prefer Ruby's comparison operators over Active Support's `inquiry`."
+        RESTRICT_ON_SEND = %i[inquiry].freeze
 
         def on_send(node)
-          add_offense(node, location: :selector) if node.method?(:inquiry) && node.arguments.empty?
+          return unless node.arguments.empty?
+          return unless (receiver = node.receiver)
+          return if !receiver.str_type? && !receiver.array_type?
+
+          add_offense(node.loc.selector)
         end
       end
     end

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

@@ -128,10 +128,11 @@ module RuboCop
       #
       # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
-      class InverseOf < Cop
+      class InverseOf < Base
         SPECIFY_MSG = 'Specify an `:inverse_of` option.'
         NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to ' \
           'use `inverse_of: false`.'
+        RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
 
         def_node_matcher :association_recv_arguments, <<~PATTERN
           (send $_ {:has_many :has_one :belongs_to} _ $...)
@@ -185,7 +186,7 @@ module RuboCop
 
           return if options_contain_inverse_of?(options)
 
-          add_offense(node, message: message(options), location: :selector)
+          add_offense(node.loc.selector, message: message(options))
         end
 
         def scope?(arguments)

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

@@ -82,25 +82,27 @@ module RuboCop
       #       @content = Article.find(params[:article_id])
       #     end
       #   end
-      class LexicallyScopedActionFilter < Cop
+      class LexicallyScopedActionFilter < Base
         MSG = '%<action>s not explicitly defined on the %<type>s.'
 
-        FILTERS = %w[
-          :after_action
-          :append_after_action
-          :append_around_action
-          :append_before_action
-          :around_action
-          :before_action
-          :prepend_after_action
-          :prepend_around_action
-          :prepend_before_action
-          :skip_after_action
-          :skip_around_action
-          :skip_before_action
-          :skip_action_callback
+        RESTRICT_ON_SEND = %i[
+          after_action
+          append_after_action
+          append_around_action
+          append_before_action
+          around_action
+          before_action
+          prepend_after_action
+          prepend_around_action
+          prepend_before_action
+          skip_after_action
+          skip_around_action
+          skip_before_action
+          skip_action_callback
         ].freeze
 
+        FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
+
         def_node_matcher :only_or_except_filter_methods, <<~PATTERN
           (send
             nil?

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

@@ -20,8 +20,11 @@ module RuboCop
       #
       #   # good
       #   link_to 'Click here', url, target: '_blank', rel: 'noreferrer'
-      class LinkToBlank < Cop
+      class LinkToBlank < Base
+        extend AutoCorrector
+
         MSG = 'Specify a `:rel` option containing noopener.'
+        RESTRICT_ON_SEND = %i[link_to].freeze
 
         def_node_matcher :blank_target?, <<~PATTERN
           (pair {(sym :target) (str "target")} {(str "_blank") (sym :_blank)})
@@ -35,39 +38,34 @@ module RuboCop
           (pair {(sym :rel) (str "rel")} (str _))
         PATTERN
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
-          return unless node.method?(:link_to)
-
           option_nodes = node.each_child_node(:hash)
 
           option_nodes.map(&:children).each do |options|
             blank = options.find { |o| blank_target?(o) }
-            add_offense(blank) if blank && options.none? { |o| includes_noopener?(o) }
+            next unless blank && options.none? { |o| includes_noopener?(o) }
+
+            add_offense(blank) do |corrector|
+              autocorrect(corrector, node, blank, option_nodes)
+            end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
-        def autocorrect(node)
-          lambda do |corrector|
-            send_node = node.parent.parent
+        private
 
-            option_nodes = send_node.each_child_node(:hash)
-            rel_node = nil
-            option_nodes.map(&:children).each do |options|
-              rel_node ||= options.find { |o| rel_node?(o) }
-            end
+        def autocorrect(corrector, send_node, node, option_nodes)
+          rel_node = nil
+          option_nodes.map(&:children).each do |options|
+            rel_node ||= options.find { |o| rel_node?(o) }
+          end
 
-            if rel_node
-              append_to_rel(rel_node, corrector)
-            else
-              add_rel(send_node, node, corrector)
-            end
+          if rel_node
+            append_to_rel(rel_node, corrector)
+          else
+            add_rel(send_node, node, corrector)
           end
         end
 
-        private
-
         def append_to_rel(rel_node, corrector)
           existing_rel = rel_node.children.last.value
           str_range = rel_node.children.last.loc.expression.adjust(
@@ -89,7 +87,7 @@ module RuboCop
         def contains_noopener?(value)
           return false unless value
 
-          rel_array = value.to_s.split(' ')
+          rel_array = value.to_s.split
           rel_array.include?('noopener') || rel_array.include?('noreferrer')
         end
       end

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

@@ -23,7 +23,9 @@ module RuboCop
       #   class UserMailer < ApplicationMailer
       #   end
       #
-      class MailerName < Cop
+      class MailerName < Base
+        extend AutoCorrector
+
         MSG = 'Mailer should end with `Mailer` suffix.'
 
         def_node_matcher :mailer_base_class?, <<~PATTERN
@@ -43,7 +45,9 @@ module RuboCop
 
         def on_class(node)
           class_definition?(node) do |name_node|
-            add_offense(name_node)
+            add_offense(name_node) do |corrector|
+              autocorrect(corrector, name_node)
+            end
           end
         end
 
@@ -54,23 +58,25 @@ module RuboCop
           return unless casgn_parent
 
           name = casgn_parent.children[1]
-          add_offense(casgn_parent, location: :name) unless mailer_suffix?(name)
-        end
+          return if mailer_suffix?(name)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.casgn_type?
-              name = node.children[1]
-              corrector.replace(node.loc.name, "#{name}Mailer")
-            else
-              name = node.children.last
-              corrector.replace(node.source_range, "#{name}Mailer")
-            end
+          add_offense(casgn_parent.loc.name) do |corrector|
+            autocorrect(corrector, casgn_parent)
           end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          if node.casgn_type?
+            name = node.children[1]
+            corrector.replace(node.loc.name, "#{name}Mailer")
+          else
+            name = node.children.last
+            corrector.replace(node.source_range, "#{name}Mailer")
+          end
+        end
+
         def mailer_suffix?(mailer_name)
           mailer_name.to_s.end_with?('Mailer')
         end

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
@@ -77,6 +78,8 @@ module RuboCop
             [via.value]
           elsif via.array_type?
             via.values.map(&:value)
+          else
+            []
           end
         end
 

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 $...))