rubocop 1.39.0 → 1.40.0

data/lib/rubocop/cop/lint/send_with_mixin_argument.rb

@@ -48,16 +48,17 @@ module RuboCop
           (send
             (const _ _) {:#{SEND_METHODS.join(' :')}}
             ({sym str} $#mixin_method?)
-              $(const _ _))
+              $(const _ _)+)
         PATTERN
 
         def on_send(node)
-          send_with_mixin_argument?(node) do |method, module_name|
-            message = message(method, module_name.source, bad_location(node).source)
+          send_with_mixin_argument?(node) do |method, module_names|
+            module_names_source = module_names.map(&:source).join(', ')
+            message = message(method, module_names_source, bad_location(node).source)
 
             bad_location = bad_location(node)
             add_offense(bad_location, message: message) do |corrector|
-              corrector.replace(bad_location, "#{method} #{module_name.source}")
+              corrector.replace(bad_location, "#{method} #{module_names_source}")
             end
           end
         end

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -73,10 +73,11 @@ module RuboCop
           outer_local_variable_node =
             find_conditional_node_from_ascendant(outer_local_variable.declaration_node)
           return true unless outer_local_variable_node
+          return false unless outer_local_variable_node.conditional?
+          return true if variable_node == outer_local_variable_node
 
-          outer_local_variable_node.conditional? &&
-            (variable_node == outer_local_variable_node ||
-              variable_node == outer_local_variable_node.else_branch)
+          outer_local_variable_node.if_type? &&
+            variable_node == outer_local_variable_node.else_branch
         end
 
         def variable_node(variable)

data/lib/rubocop/cop/lint/void.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for operators, variables, literals, and nonmutating
+      # Checks for operators, variables, literals, lambda, proc and nonmutating
       # methods used in void context.
       #
       # @example CheckForMethodsWithNoSideEffects: false (default)
@@ -45,7 +45,7 @@ module RuboCop
         VAR_MSG = 'Variable `%<var>s` used in void context.'
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
         SELF_MSG = '`self` used in void context.'
-        DEFINED_MSG = '`%<defined>s` used in void context.'
+        EXPRESSION_MSG = '`%<expression>s` used in void context.'
         NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
@@ -87,7 +87,7 @@ module RuboCop
           check_literal(expr)
           check_var(expr)
           check_self(expr)
-          check_defined(expr)
+          check_void_expression(expr)
           return unless cop_config['CheckForMethodsWithNoSideEffects']
 
           check_nonmutating(expr)
@@ -117,10 +117,10 @@ module RuboCop
           add_offense(node, message: SELF_MSG)
         end
 
-        def check_defined(node)
-          return unless node.defined_type?
+        def check_void_expression(node)
+          return unless node.defined_type? || node.lambda_or_proc?
 
-          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
+          add_offense(node, message: format(EXPRESSION_MSG, expression: node.source))
         end
 
         def check_nonmutating(node)

data/lib/rubocop/cop/metrics/block_length.rb

@@ -8,8 +8,8 @@ module RuboCop
       # The maximum allowed length is configurable.
       # The cop can be configured to ignore blocks passed to certain methods.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
       #
@@ -17,7 +17,7 @@ module RuboCop
       # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
       # instead. By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   something do
       #     array = [         # +1
@@ -33,7 +33,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base

data/lib/rubocop/cop/metrics/class_length.rb

@@ -7,11 +7,11 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   class Foo
       #     ARRAY = [         # +1
@@ -27,7 +27,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       #
       # NOTE: This cop also applies for `Struct` definitions.

data/lib/rubocop/cop/metrics/method_length.rb

@@ -7,8 +7,8 @@ module RuboCop
       # Comment lines can optionally be allowed.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
       # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
@@ -16,7 +16,7 @@ module RuboCop
       # Please use `AllowedMethods` and `AllowedPatterns` instead.
       # By default, there are no methods to allowed.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   def m
       #     array = [       # +1
@@ -32,7 +32,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end               # 5 points
+      #
+      #     foo(            # +1
+      #       1,
+      #       2
+      #     )
+      #   end               # 6 points
       #
       class MethodLength < Base
         include CodeLength

data/lib/rubocop/cop/metrics/module_length.rb

@@ -7,11 +7,11 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       #
-      # You can set literals you want to fold with `CountAsOne`.
-      # Available are: 'array', 'hash', and 'heredoc'. Each literal
+      # You can set constructs you want to fold with `CountAsOne`.
+      # Available are: 'array', 'hash', 'heredoc', and 'method_call'. Each construct
       # will be counted as one line regardless of its actual size.
       #
-      # @example CountAsOne: ['array', 'heredoc']
+      # @example CountAsOne: ['array', 'heredoc', 'method_call']
       #
       #   module M
       #     ARRAY = [         # +1
@@ -27,7 +27,12 @@ module RuboCop
       #       Heredoc
       #       content.
       #     HEREDOC
-      #   end                 # 5 points
+      #
+      #     foo(              # +1
+      #       1,
+      #       2
+      #     )
+      #   end                 # 6 points
       #
       class ModuleLength < Base
         include CodeLength

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -9,7 +9,7 @@ module RuboCop
           extend NodePattern::Macros
           include Util
 
-          FOLDABLE_TYPES = %i[array hash heredoc].freeze
+          FOLDABLE_TYPES = %i[array hash heredoc send csend].freeze
           CLASSLIKE_TYPES = %i[class module].freeze
           private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
 
@@ -39,7 +39,7 @@ module RuboCop
 
           private
 
-          def build_foldable_checks(types)
+          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
             types.map do |type|
               case type
               when :array
@@ -48,6 +48,8 @@ module RuboCop
                 ->(node) { node.hash_type? }
               when :heredoc
                 ->(node) { heredoc_node?(node) }
+              when :method_call
+                ->(node) { node.call_type? }
               else
                 raise ArgumentError, "Unknown foldable type: #{type.inspect}. " \
                                      "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
@@ -57,6 +59,7 @@ module RuboCop
 
           def normalize_foldable_types(types)
             types.concat(%i[str dstr]) if types.delete(:heredoc)
+            types.concat(%i[send csend]) if types.delete(:method_call)
             types
           end
 

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -47,6 +47,12 @@ module RuboCop
 
       def register_offense(node, message, replacement)
         add_offense(node.value, message: message) do |corrector|
+          if (def_node = def_node_that_require_parentheses(node))
+            white_spaces = range_between(def_node.loc.selector.end_pos,
+                                         def_node.first_argument.source_range.begin_pos)
+            corrector.replace(white_spaces, '(')
+            corrector.insert_after(def_node.arguments.last, ')')
+          end
           corrector.replace(node, replacement)
         end
       end
@@ -76,12 +82,25 @@ module RuboCop
       end
 
       def require_hash_value_for_around_hash_literal?(node)
-        return false unless (ancestor = node.parent.parent)
-        return false if ancestor.send_type? && ancestor.method?(:[])
+        return false unless (send_node = find_ancestor_send_node(node))
+
+        !node.parent.braces? && !use_element_of_hash_literal_as_receiver?(send_node, node.parent) &&
+          use_modifier_form_without_parenthesized_method_call?(send_node)
+      end
+
+      def def_node_that_require_parentheses(node)
+        return unless (send_node = find_ancestor_send_node(node))
+        return unless without_parentheses_call_expr_follows?(send_node)
+
+        def_node = node.each_ancestor(:send, :csend).first
+
+        def_node unless def_node && def_node.arguments.empty?
+      end
+
+      def find_ancestor_send_node(node)
+        ancestor = node.parent.parent
 
-        !node.parent.braces? && !use_element_of_hash_literal_as_receiver?(ancestor, node.parent) &&
-          (use_modifier_form_without_parenthesized_method_call?(ancestor) ||
-           without_parentheses_call_expr_follows?(ancestor))
+        ancestor if ancestor&.call_type? && !ancestor&.method?(:[])
       end
 
       def use_element_of_hash_literal_as_receiver?(ancestor, parent)

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -48,11 +48,25 @@ module RuboCop
       end
 
       def to_modifier_form(node)
-        expression = [node.body.source, node.keyword, node.condition.source].compact.join(' ')
+        body = if_body_source(node.body)
+        expression = [body, node.keyword, node.condition.source].compact.join(' ')
         parenthesized = parenthesize?(node) ? "(#{expression})" : expression
         [parenthesized, first_line_comment(node)].compact.join(' ')
       end
 
+      def if_body_source(if_body)
+        if if_body.call_type? &&
+           if_body.last_argument&.hash_type? && if_body.last_argument.pairs.last.value_omission?
+          "#{method_source(if_body)}(#{if_body.arguments.map(&:source).join(', ')})"
+        else
+          if_body.source
+        end
+      end
+
+      def method_source(if_body)
+        range_between(if_body.loc.expression.begin_pos, if_body.loc.selector.end_pos).source
+      end
+
       def first_line_comment(node)
         comment = processed_source.find_comment { |c| same_line?(c, node) }
         return unless comment

data/lib/rubocop/cop/registry.rb

@@ -72,27 +72,27 @@ module RuboCop
       #
       # @example gives back a correctly qualified cop name
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.
-      #     qualified_cop_name('Layout/EndOfLine') # => 'Layout/EndOfLine'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Layout/EndOfLine', '') # => 'Layout/EndOfLine'
       #
       # @example fixes incorrect namespaces
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('Lint/EndOfLine') # => 'Layout/EndOfLine'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('Lint/EndOfLine', '') # => 'Layout/EndOfLine'
       #
       # @example namespaces bare cop identifiers
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('EndOfLine') # => 'Layout/EndOfLine'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('EndOfLine', '') # => 'Layout/EndOfLine'
       #
       # @example passes back unrecognized cop names
       #
-      #   cops = RuboCop::Cop::Cop.all
-      #   cops.qualified_cop_name('NotACop') # => 'NotACop'
+      #   registry = RuboCop::Cop::Registry
+      #   registry.qualified_cop_name('NotACop', '') # => 'NotACop'
       #
       # @param name [String] Cop name extracted from config
       # @param path [String, nil] Path of file that `name` was extracted from
+      # @param warn [Boolean] Print a warning if no department given for `name`
       #
       # @raise [AmbiguousCopName]
       #   if a bare identifier with two possible namespaces is provided
@@ -158,7 +158,7 @@ module RuboCop
       end
 
       def enabled?(cop, config)
-        return true if options.fetch(:only, []).include?(cop.cop_name)
+        return true if options[:only]&.include?(cop.cop_name)
 
         cfg = config.for_cop(cop)
 
@@ -182,8 +182,12 @@ module RuboCop
         cops.map(&:cop_name)
       end
 
+      def cops_for_department(department)
+        cops.select { |cop| cop.department == department.to_sym }
+      end
+
       def names_for_department(department)
-        cops.select { |cop| cop.department == department.to_sym }.map(&:cop_name)
+        cops_for_department(department).map(&:cop_name)
       end
 
       def ==(other)
@@ -211,6 +215,14 @@ module RuboCop
         to_h[cop_name].first
       end
 
+      # When a cop name is given returns a single-element array with the cop class.
+      # When a department name is given returns an array with all the cop classes
+      # for that department.
+      def find_cops_by_directive(directive)
+        cop = find_by_cop_name(directive)
+        cop ? [cop] : cops_for_department(directive)
+      end
+
       def freeze
         clear_enrollment_queue
         unqualified_cop_names # build cache

data/lib/rubocop/cop/style/array_intersect.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # In Ruby 3.1, `Array#intersect?` has been added.
+      #
+      # This cop identifies places where `(array1 & array2).any?`
+      # can be replaced by `array1.intersect?(array2)`.
+      #
+      # The `array1.intersect?(array2)` method is faster than
+      # `(array1 & array2).any?` and is more readable.
+      #
+      # @safety
+      #   This cop cannot guarantee that array1 and array2 are
+      #   actually arrays while method `intersect?` is for arrays only.
+      #
+      # @example
+      #   # bad
+      #   (array1 & array2).any?
+      #   (array1 & array2).empty?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #   !array1.intersect?(array2)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #   # good
+      #   (array1 & array2).present?
+      #   (array1 & array2).blank?
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #   # bad
+      #   (array1 & array2).present?
+      #   (array1 & array2).blank?
+      #
+      #   # good
+      #   array1.intersect?(array2)
+      #   !array1.intersect?(array2)
+      class ArrayIntersect < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 3.1
+
+        # @!method regular_bad_intersection_check?(node)
+        def_node_matcher :regular_bad_intersection_check?, <<~PATTERN
+          (send
+            (begin
+              (send $(...) :& $(...))
+            ) ${:any? :empty?}
+          )
+        PATTERN
+
+        # @!method active_support_bad_intersection_check?(node)
+        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
+          (send
+            (begin
+              (send $(...) :& $(...))
+            ) ${:present? :any? :blank? :empty?}
+          )
+        PATTERN
+
+        MSG = 'Use `%<negated>s%<receiver>s.intersect?(%<argument>s)` ' \
+              'instead of `(%<receiver>s & %<argument>s).%<method_name>s`.'
+        STRAIGHT_METHODS = %i[present? any?].freeze
+        NEGATED_METHODS = %i[blank? empty?].freeze
+        RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
+
+        def on_send(node)
+          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+
+          message = message(receiver.source, argument.source, method_name)
+
+          add_offense(node, message: message) do |corrector|
+            if straight?(method_name)
+              corrector.replace(node, "#{receiver.source}.intersect?(#{argument.source})")
+            else
+              corrector.replace(node, "!#{receiver.source}.intersect?(#{argument.source})")
+            end
+          end
+        end
+
+        private
+
+        def bad_intersection_check?(node)
+          if active_support_extensions_enabled?
+            active_support_bad_intersection_check?(node)
+          else
+            regular_bad_intersection_check?(node)
+          end
+        end
+
+        def straight?(method_name)
+          STRAIGHT_METHODS.include?(method_name.to_sym)
+        end
+
+        def message(receiver, argument, method_name)
+          negated = straight?(method_name) ? '' : '!'
+          format(
+            MSG,
+            negated: negated,
+            receiver: receiver,
+            argument: argument,
+            method_name: method_name
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/guard_clause.rb

@@ -94,6 +94,7 @@ module RuboCop
       #
       class GuardClause < Base
         extend AutoCorrector
+        include RangeHelp
         include MinBodyLength
         include StatementModifier
 
@@ -179,13 +180,35 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def autocorrect(corrector, node, condition, replacement, guard)
           corrector.replace(node.loc.keyword.join(condition.loc.expression), replacement)
-          corrector.remove(node.loc.end)
-          return unless node.else?
 
-          corrector.remove(node.loc.else)
-          corrector.remove(branch_to_remove(node, guard))
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+
+          if if_branch&.send_type? && if_branch.last_argument&.heredoc?
+            autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
+          elsif else_branch&.send_type? && else_branch.last_argument&.heredoc?
+            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
+          else
+            corrector.remove(node.loc.end)
+            return unless node.else?
+
+            corrector.remove(node.loc.else)
+            corrector.remove(branch_to_remove(node, guard))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+          remove_whole_lines(corrector, leave_branch.source_range)
+          remove_whole_lines(corrector, node.loc.else)
+          remove_whole_lines(corrector, node.loc.end)
+          remove_whole_lines(corrector, branch_to_remove(node, guard).source_range)
+          corrector.insert_after(
+            heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
+          )
         end
 
         def branch_to_remove(node, guard)
@@ -222,7 +245,7 @@ module RuboCop
         end
 
         def accepted_if?(node, ending)
-          return true if node.modifier_form? || node.ternary?
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional?
 
           if ending
             node.else?
@@ -231,6 +254,10 @@ module RuboCop
           end
         end
 
+        def remove_whole_lines(corrector, range)
+          corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        end
+
         def allowed_consecutive_conditionals?
           cop_config.fetch('AllowConsecutiveConditionals', false)
         end

data/lib/rubocop/cop/style/if_with_semicolon.rb

@@ -39,9 +39,10 @@ module RuboCop
         def autocorrect(node)
           return correct_elsif(node) if node.else_branch.if_type?
 
+          then_code = node.if_branch ? node.if_branch.source : 'nil'
           else_code = node.else_branch ? node.else_branch.source : 'nil'
 
-          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+          "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
 
         def correct_elsif(node)

data/lib/rubocop/cop/style/nil_lambda.rb

@@ -44,7 +44,7 @@ module RuboCop
         PATTERN
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-          return unless node.lambda? || node.proc?
+          return unless node.lambda_or_proc?
           return unless nil_return?(node.body)
 
           message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')

data/lib/rubocop/cop/style/redundant_argument.rb

@@ -13,6 +13,7 @@ module RuboCop
       # ----
       # Methods:
       #   join: ''
+      #   sum: 0
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
@@ -33,6 +34,7 @@ module RuboCop
       #   # bad
       #   array.join('')
       #   [1, 2, 3].join("")
+      #   array.sum(0)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -42,6 +44,7 @@ module RuboCop
       #   # good
       #   array.join
       #   [1, 2, 3].join
+      #   array.sum
       #   string.split
       #   "first second".split
       #   string.chomp