rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for uses of `each_with_object({}) { ... }`,
+      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
+      # an enumerable into a hash where the keys are the original elements.
+      # Rails provides the `index_with` method for this purpose.
+      #
+      # @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 < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+        include IndexMethod
+
+        minimum_target_rails_version 6.0
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            (call _ :each_with_object (hash))
+            (args (arg $_el) (arg _memo))
+            (call (lvar _memo) :[]= (lvar _el) $!`_memo))
+        PATTERN
+
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            (call _ :to_h)
+            (args (arg $_el))
+            (array (lvar _el) $_))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          (call
+            (block
+              (call _ {:map :collect})
+              (args (arg $_el))
+              (array (lvar _el) $_))
+            :to_h)
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const {nil? cbase} :Hash)
+            :[]
+            (block
+              (call _ {:map :collect})
+              (args (arg $_el))
+              (array (lvar _el) $_)))
+        PATTERN
+
+        private
+
+        def new_method_name
+          'index_with'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks that Active Support's `inquiry` method is not used.
+      #
+      # @example
+      #   # bad - String#inquiry
+      #   ruby = 'two'.inquiry
+      #   ruby.two?
+      #
+      #   # good
+      #   ruby = 'two'
+      #   ruby == 'two'
+      #
+      #   # bad - Array#inquiry
+      #   pets = %w(cat dog).inquiry
+      #   pets.gopher?
+      #
+      #   # good
+      #   pets = %w(cat dog)
+      #   pets.include? 'cat'
+      #
+      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.arguments.empty?
+          return unless (receiver = node.receiver)
+          return if !receiver.str_type? && !receiver.array_type?
+
+          add_offense(node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for has_(one|many) and belongs_to associations where
+      # Looks for has_(one|many) and belongs_to associations where
       # Active Record can't automatically determine the inverse association
       # because of a scope or the options used. Using the blog with order scope
       # example below, traversing the a Blog's association in both directions
@@ -126,50 +126,55 @@ module RuboCop
       #     has_many :physicians, through: :appointments
       #   end
       #
-      # @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
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 4.1
-
+      # @example IgnoreScopes: false (default)
+      #   # bad
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      # @example IgnoreScopes: true
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      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`.'
+        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
+        def_node_matcher :association_recv_arguments, <<~PATTERN
           (send $_ {:has_many :has_one :belongs_to} _ $...)
         PATTERN
 
-        def_node_matcher :options_from_argument, <<-PATTERN
+        def_node_matcher :options_from_argument, <<~PATTERN
           (hash $...)
         PATTERN
 
-        def_node_matcher :conditions_option?, <<-PATTERN
+        def_node_matcher :conditions_option?, <<~PATTERN
           (pair (sym :conditions) !nil)
         PATTERN
 
-        def_node_matcher :through_option?, <<-PATTERN
+        def_node_matcher :through_option?, <<~PATTERN
           (pair (sym :through) !nil)
         PATTERN
 
-        def_node_matcher :polymorphic_option?, <<-PATTERN
+        def_node_matcher :polymorphic_option?, <<~PATTERN
           (pair (sym :polymorphic) !nil)
         PATTERN
 
-        def_node_matcher :as_option?, <<-PATTERN
+        def_node_matcher :as_option?, <<~PATTERN
           (pair (sym :as) !nil)
         PATTERN
 
-        def_node_matcher :foreign_key_option?, <<-PATTERN
+        def_node_matcher :foreign_key_option?, <<~PATTERN
           (pair (sym :foreign_key) !nil)
         PATTERN
 
-        def_node_matcher :inverse_of_option?, <<-PATTERN
+        def_node_matcher :inverse_of_option?, <<~PATTERN
           (pair (sym :inverse_of) !nil)
         PATTERN
 
-        def_node_matcher :inverse_of_nil_option?, <<-PATTERN
+        def_node_matcher :inverse_of_nil_option?, <<~PATTERN
           (pair (sym :inverse_of) nil)
         PATTERN
 
@@ -184,22 +189,20 @@ module RuboCop
           end
           return if options_ignoring_inverse_of?(options)
 
-          return unless scope?(arguments) ||
-                        options_requiring_inverse_of?(options)
+          return unless scope?(arguments) || options_requiring_inverse_of?(options)
 
           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)
-          arguments.any?(&:block_type?)
+          !ignore_scopes? && arguments.any?(&:block_type?)
         end
 
         def options_requiring_inverse_of?(options)
           required = options.any? do |opt|
-            conditions_option?(opt) ||
-              foreign_key_option?(opt)
+            conditions_option?(opt) || foreign_key_option?(opt)
           end
 
           return required if target_rails_version >= 5.2
@@ -219,8 +222,7 @@ module RuboCop
 
         def with_options_arguments(recv, node)
           blocks = node.each_ancestor(:block).select do |block|
-            block.send_node.command?(:with_options) &&
-              same_context_in_with_options?(block.arguments.first, recv)
+            block.send_node.command?(:with_options) && same_context_in_with_options?(block.arguments.first, recv)
           end
           blocks.flat_map { |n| n.send_node.arguments }
         end
@@ -240,6 +242,10 @@ module RuboCop
             SPECIFY_MSG
           end
         end
+
+        def ignore_scopes?
+          cop_config['IgnoreScopes'] == true
+        end
       end
     end
   end

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

@@ -3,16 +3,17 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that methods specified in the filter's `only` or
+      # Checks that methods specified in the filter's `only` or
       # `except` options are defined within the same class or module.
       #
-      # You can technically specify methods of superclass or methods added by
-      # mixins on the filter, but these can confuse developers. If you specify
-      # methods that are defined in other classes or modules, you should
-      # define the filter in that class or module.
+      # @safety
+      #   You can technically specify methods of superclass or methods added by
+      #   mixins on the filter, but these can confuse developers. If you specify
+      #   methods that are defined in other classes or modules, you should
+      #   define the filter in that class or module.
       #
-      # If you rely on behaviour defined in the superclass actions, you must
-      # remember to invoke `super` in the subclass actions.
+      #   If you rely on behavior defined in the superclass actions, you must
+      #   remember to invoke `super` in the subclass actions.
       #
       # @example
       #   # bad
@@ -70,7 +71,7 @@ module RuboCop
       #   class ArticlesController < ContentController
       #     before_action :load_article, only: [:update]
       #
-      #     # the cop requires this method, but it relies on behaviour defined
+      #     # the cop requires this method, but it relies on behavior defined
       #     # in the superclass, so needs to invoke `super`
       #     def update
       #       super
@@ -82,26 +83,28 @@ 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
 
-        def_node_matcher :only_or_except_filter_methods, <<-PATTERN
+        FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
+
+        def_node_matcher :only_or_except_filter_methods, <<~PATTERN
           (send
             nil?
             {#{FILTERS.join(' ')}}
@@ -122,9 +125,10 @@ module RuboCop
           block = parent.each_child_node(:begin).first
           return unless block
 
-          defined_methods = block.each_child_node(:def).map(&:method_name)
+          defined_action_methods = defined_action_methods(block)
+
           methods = array_values(methods_node).reject do |method|
-            defined_methods.include?(method)
+            defined_action_methods.include?(method)
           end
 
           message = message(methods, parent)
@@ -133,6 +137,36 @@ module RuboCop
 
         private
 
+        def defined_action_methods(block)
+          defined_methods = block.each_child_node(:def).map(&:method_name)
+
+          defined_methods + aliased_action_methods(block, defined_methods)
+        end
+
+        def aliased_action_methods(node, defined_methods)
+          alias_methods = alias_methods(node)
+          defined_methods.each_with_object([]) do |defined_method, aliased_method|
+            if (new_method_name = alias_methods[defined_method])
+              aliased_method << new_method_name
+            end
+          end
+        end
+
+        def alias_methods(node)
+          result = {}
+          node.each_child_node(:send, :alias) do |child_node|
+            case child_node.type
+            when :send
+              if child_node.method?(:alias_method)
+                result[child_node.last_argument.value] = child_node.first_argument.value
+              end
+            when :alias
+              result[child_node.old_identifier.value] = child_node.new_identifier.value
+            end
+          end
+          result
+        end
+
         # @param node [RuboCop::AST::Node]
         # @return [Array<Symbol>]
         def array_values(node) # rubocop:disable Metrics/MethodLength
@@ -160,13 +194,9 @@ module RuboCop
         # @return [String]
         def message(methods, parent)
           if methods.size == 1
-            format(MSG,
-                   action: "`#{methods[0]}` is",
-                   type: parent.type)
+            format(MSG, action: "`#{methods[0]}` is", type: parent.type)
           else
-            format(MSG,
-                   action: "`#{methods.join('`, `')}` are",
-                   type: parent.type)
+            format(MSG, action: "`#{methods.join('`, `')}` are", type: parent.type)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for calls to `link_to` that contain a
+      # Checks for calls to `link_to` that contain a
       # `target: '_blank'` but no `rel: 'noopener'`. This can be a security
       # risk as the loaded page will have control over the previous page
       # and could change its location for phishing purposes.
@@ -20,68 +20,67 @@ 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
+        def_node_matcher :blank_target?, <<~PATTERN
           (pair {(sym :target) (str "target")} {(str "_blank") (sym :_blank)})
         PATTERN
 
-        def_node_matcher :includes_noopener?, <<-PATTERN
+        def_node_matcher :includes_noopener?, <<~PATTERN
           (pair {(sym :rel) (str "rel")} ({str sym} #contains_noopener?))
         PATTERN
 
-        def_node_matcher :rel_node?, <<-PATTERN
+        def_node_matcher :rel_node?, <<~PATTERN
           (pair {(sym :rel) (str "rel")} (str _))
         PATTERN
 
         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) }
-            if blank && options.none? { |o| includes_noopener?(o) }
-              add_offense(blank)
+            next unless blank && options.none? { |o| includes_noopener?(o) }
+
+            add_offense(blank) do |corrector|
+              autocorrect(corrector, node, blank, option_nodes)
             end
           end
         end
 
-        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(
-            begin_pos: 1,
-            end_pos: -1
-          )
+          str_range = rel_node.children.last.source_range.adjust(begin_pos: 1, end_pos: -1)
           corrector.replace(str_range, "#{existing_rel} noopener")
         end
 
-        def add_rel(send_node, offence_node, corrector)
-          opening_quote = offence_node.children.last.source[0]
+        def add_rel(send_node, offense_node, corrector)
+          opening_quote = offense_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 +88,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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces that mailer names end with `Mailer` suffix.
+      #
+      # Without the `Mailer` suffix it isn't immediately apparent what's a mailer
+      # and which views are related to the mailer.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because renaming a constant is
+      #   always an unsafe operation.
+      #
+      # @example
+      #   # bad
+      #   class User < ActionMailer::Base
+      #   end
+      #
+      #   class User < ApplicationMailer
+      #   end
+      #
+      #   # good
+      #   class UserMailer < ActionMailer::Base
+      #   end
+      #
+      #   class UserMailer < ApplicationMailer
+      #   end
+      #
+      class MailerName < Base
+        extend AutoCorrector
+
+        MSG = 'Mailer should end with `Mailer` suffix.'
+
+        def_node_matcher :mailer_base_class?, <<~PATTERN
+          {
+            (const (const {nil? cbase} :ActionMailer) :Base)
+            (const {nil? cbase} :ApplicationMailer)
+          }
+        PATTERN
+
+        def_node_matcher :class_definition?, <<~PATTERN
+          (class $(const _ !#mailer_suffix?) #mailer_base_class? ...)
+        PATTERN
+
+        def_node_matcher :class_new_definition?, <<~PATTERN
+          (send (const {nil? cbase} :Class) :new #mailer_base_class?)
+        PATTERN
+
+        def on_class(node)
+          class_definition?(node) do |name_node|
+            add_offense(name_node) do |corrector|
+              autocorrect(corrector, name_node)
+            end
+          end
+        end
+
+        def on_send(node)
+          return unless class_new_definition?(node)
+
+          casgn_parent = node.each_ancestor(:casgn).first
+          return unless casgn_parent
+
+          name = casgn_parent.children[1]
+          return if mailer_suffix?(name)
+
+          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, "#{name}Mailer")
+          end
+        end
+
+        def mailer_suffix?(mailer_name)
+          mailer_name.to_s.end_with?('Mailer')
+        end
+      end
+    end
+  end
+end