rubocop-rails 2.8.1 → 2.11.0

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

@@ -17,7 +17,9 @@ module RuboCop
       #   # good
       #   get :new, params: { user_id: 1 }
       #   get :new, **options
-      class HttpPositionalArguments < Cop
+      class HttpPositionalArguments < Base
+        include RangeHelp
+        extend AutoCorrector
         extend TargetRailsVersion
 
         MSG = 'Use keyword arguments instead of ' \
@@ -25,12 +27,12 @@ module RuboCop
         KEYWORD_ARGS = %i[
           method params session body flash xhr as headers env to
         ].freeze
-        HTTP_METHODS = %i[get post put patch delete head].freeze
+        RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
         minimum_target_rails_version 5.0
 
         def_node_matcher :http_request?, <<~PATTERN
-          (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_ ...)
+          (send nil? {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} !nil? $_ ...)
         PATTERN
 
         def_node_matcher :kwsplat_hash?, <<~PATTERN
@@ -41,24 +43,21 @@ module RuboCop
           http_request?(node) do |data|
             return unless needs_conversion?(data)
 
-            add_offense(node, location: :selector,
-                              message: format(MSG, verb: node.method_name))
-          end
-        end
-
-        # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
-        #
-        # @return lambda of auto correct procedure
-        # the result should look like:
-        #     get :new, params: { user_id: @user.id }, session: {}
-        # the http_method is the method used to call the controller
-        # the controller node can be a symbol, method, object or string
-        # that represents the path/action on the Rails controller
-        # the data is the http parameters and environment sent in
-        # the Rails 5 http call
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, correction(node))
+            message = format(MSG, verb: node.method_name)
+
+            add_offense(highlight_range(node), message: message) do |corrector|
+              # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
+              #
+              # @return lambda of auto correct procedure
+              # the result should look like:
+              #     get :new, params: { user_id: @user.id }, session: {}
+              # the http_method is the method used to call the controller
+              # the controller node can be a symbol, method, object or string
+              # that represents the path/action on the Rails controller
+              # the data is the http parameters and environment sent in
+              # the Rails 5 http call
+              corrector.replace(node.loc.expression, correction(node))
+            end
           end
         end
 
@@ -82,6 +81,12 @@ module RuboCop
           node.sym_type? && node.value == :format
         end
 
+        def highlight_range(node)
+          _http_path, *data = *node.arguments
+
+          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
+        end
+
         def convert_hash_data(data, type)
           return '' if data.hash_type? && data.empty?
 

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

@@ -11,12 +11,14 @@ module RuboCop
       #   render json: { foo: 'bar' }, status: 200
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
+      #   head 200
       #
       #   # good
       #   render :foo, status: :ok
       #   render json: { foo: 'bar' }, status: :ok
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
       #
       # @example EnforcedStyle: numeric
       #   # bad
@@ -24,20 +26,26 @@ module RuboCop
       #   render json: { foo: 'bar' }, status: :not_found
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
       #
       #   # good
       #   render :foo, status: 200
       #   render json: { foo: 'bar' }, status: 404
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
+      #   head 200
       #
-      class HttpStatus < Cop
+      class HttpStatus < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
             (send nil? {:render :redirect_to} _ $hash)
             (send nil? {:render :redirect_to} $hash)
+            (send nil? :head ${int sym} ...)
           }
         PATTERN
 
@@ -46,21 +54,20 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          http_status(node) do |hash_node|
-            status = status_code(hash_node)
+          http_status(node) do |hash_node_or_status_code|
+            status = if hash_node_or_status_code.hash_type?
+                       status_code(hash_node_or_status_code)
+                     else
+                       hash_node_or_status_code
+                     end
             return unless status
 
             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/i18n_locale_assignment.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of `I18n.locale=` method.
+      #
+      # The `locale` attribute persists for the rest of the Ruby runtime, potentially causing
+      # unexpected behavior at a later time.
+      # Using `I18n.with_locale` ensures the code passed in the block is the only place `I18n.locale` is affected.
+      # It eliminates the possibility of a `locale` sticking around longer than intended.
+      #
+      # @example
+      #   # bad
+      #   I18n.locale = :fr
+      #
+      #   # good
+      #   I18n.with_locale(:fr) do
+      #   end
+      #
+      class I18nLocaleAssignment < Base
+        MSG = 'Use `I18n.with_locale` with block instead of `I18n.locale=`.'
+        RESTRICT_ON_SEND = %i[locale=].freeze
+
+        def_node_matcher :i18n_locale_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :I18n) :locale= ...)
+        PATTERN
+
+        def on_send(node)
+          return unless i18n_locale_assignment?(node)
+
+          add_offense(node)
+        end
+      end
+    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

@@ -17,8 +17,9 @@ module RuboCop
       #
       #   # 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

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

@@ -17,7 +17,8 @@ module RuboCop
       #
       #   # good
       #   [1, 2, 3].index_with { |el| foo(el) }
-      class IndexWith < Cop
+      class IndexWith < Base
+        extend AutoCorrector
         extend TargetRailsVersion
         include IndexMethod
 

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

@@ -22,15 +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)
-          return unless 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, location: :selector)
+          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(
@@ -81,7 +79,11 @@ module RuboCop
           opening_quote = offence_node.children.last.source[0]
           closing_quote = opening_quote == ':' ? '' : opening_quote
           new_rel_exp = ", rel: #{opening_quote}noopener#{closing_quote}"
-          range = send_node.arguments.last.source_range
+          range = if (last_argument = send_node.last_argument).hash_type?
+                    last_argument.pairs.last.source_range
+                  else
+                    last_argument.source_range
+                  end
 
           corrector.insert_after(range, new_rel_exp)
         end
@@ -89,7 +91,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