rubocop 1.41.1 → 1.45.1

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

@@ -46,19 +46,23 @@ module RuboCop
         LIT_MSG = 'Literal `%<lit>s` used in void context.'
         SELF_MSG = '`self` 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!`?'
+        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<suggest>s`?'
 
         BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
         VOID_CONTEXT_TYPES = %i[def for block].freeze
-        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
-                                 delete_prefix delete_suffix downcase
-                                 encode flatten gsub lstrip map merge next
-                                 reject reverse rotate rstrip scrub select
-                                 shuffle slice sort sort_by squeeze strip sub
-                                 succ swapcase tr tr_s transform_values
-                                 unicode_normalize uniq upcase].freeze
+        NONMUTATING_METHODS_WITH_BANG_VERSION = %i[capitalize chomp chop compact
+                                                   delete_prefix delete_suffix downcase
+                                                   encode flatten gsub lstrip merge next
+                                                   reject reverse rotate rstrip scrub select
+                                                   shuffle slice sort sort_by squeeze strip sub
+                                                   succ swapcase tr tr_s transform_values
+                                                   unicode_normalize uniq upcase].freeze
+        METHODS_REPLACABLE_BY_EACH = %i[collect map].freeze
+
+        NONMUTATING_METHODS = (NONMUTATING_METHODS_WITH_BANG_VERSION +
+                               METHODS_REPLACABLE_BY_EACH).freeze
 
         def on_block(node)
           return unless node.body && !node.body.begin_type?
@@ -124,9 +128,14 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return unless node.send_type? && NONMUTATING_METHODS.include?(node.method_name)
+          return unless node.respond_to?(:method_name)
 
-          add_offense(node, message: format(NONMUTATING_MSG, method: node.method_name))
+          method_name = node.method_name
+          return unless NONMUTATING_METHODS.include?(method_name)
+
+          suggestion = METHODS_REPLACABLE_BY_EACH.include?(method_name) ? 'each' : "#{method_name}!"
+          add_offense(node,
+                      message: format(NONMUTATING_MSG, method: method_name, suggest: suggestion))
         end
 
         def in_void_context?(node)

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

@@ -51,7 +51,7 @@ module RuboCop
         def on_block(node)
           return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
-          return if node.class_constructor? || node.struct_constructor?
+          return if node.class_constructor?
 
           check_code_length(node)
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Base
-        NESTING_BLOCKS = %i[case if while while_post until until_post for resbody].freeze
+        NESTING_BLOCKS = %i[case case_match if while while_post until until_post for resbody].freeze
 
         exclude_limit 'Max'
 

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

@@ -35,7 +35,7 @@ module RuboCop
 
         MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
         COUNTED_NODES = %i[if while until for csend block block_pass
-                           rescue when and or or_asgn and_asgn].freeze
+                           rescue when in_pattern and or or_asgn and_asgn].freeze
 
         private
 

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

@@ -9,6 +9,20 @@ module RuboCop
       # Keyword arguments can optionally be excluded from the total count,
       # as they add less complexity than positional or optional parameters.
       #
+      # Any number of arguments for `initialize` method inside a block of
+      # `Struct.new` and `Data.define` like this is always allowed:
+      #
+      # [source,ruby]
+      # ----
+      # Struct.new(:one, :two, :three, :four, :five, keyword_init: true) do
+      #   def initialize(one:, two:, three:, four:, five:)
+      #   end
+      # end
+      # ----
+      #
+      # This is because checking the number of arguments of the `initialize` method
+      # does not make sense.
+      #
       # NOTE: Explicit block argument `&block` is not counted to prevent
       # erroneous change that is avoided by making block argument implicit.
       #
@@ -63,6 +77,16 @@ module RuboCop
         NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
         private_constant :NAMED_KEYWORD_TYPES
 
+        # @!method struct_new_or_data_define_block?(node)
+        def_node_matcher :struct_new_or_data_define_block?, <<~PATTERN
+          (block
+            {
+              (send (const {nil? cbase} :Struct) :new ...)
+              (send (const {nil? cbase} :Data) :define ...)
+            }
+            (args) ...)
+        PATTERN
+
         def on_def(node)
           optargs = node.arguments.select(&:optarg_type?)
           return if optargs.count <= max_optional_parameters
@@ -78,6 +102,9 @@ module RuboCop
         alias on_defs on_def
 
         def on_args(node)
+          parent = node.parent
+          return if parent.method?(:initialize) && struct_new_or_data_define_block?(parent.parent)
+
           count = args_count(node)
           return unless count > max_params
 

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

@@ -45,7 +45,7 @@ module RuboCop
             else
               # Otherwise, the case node gets 0.8 complexity points and each
               # when gets 0.2.
-              (0.8 + (0.2 * nb_branches)).round
+              ((nb_branches * 0.2) + 0.8).round
             end
           when :if
             node.else? && !node.elsif? ? 2 : 1

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

@@ -25,15 +25,12 @@ module RuboCop
           # > http://c2.com/cgi/wiki?AbcMetric
           CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
+          private_constant :BRANCH_NODES, :CONDITION_NODES
+
           def self.calculate(node, discount_repeated_attributes: false)
             new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
           end
 
-          # TODO: move to rubocop-ast
-          ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
-
-          private_constant :BRANCH_NODES, :CONDITION_NODES, :ARGUMENT_TYPES
-
           def initialize(node)
             @assignment = 0
             @branch = 0
@@ -129,7 +126,7 @@ module RuboCop
           end
 
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
+            node.argument_type? && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

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

@@ -12,7 +12,7 @@ module RuboCop
       attr_reader :column_delta
 
       def configured_indentation_width
-        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width']
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
       end
 
       def indentation(node)

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

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     # This module encapsulates the ability to allow certain methods when
-    # parsing.
+    # parsing. Even if the code is in offense, if it contains methods
+    # that are allowed. This module is equivalent to the IgnoredMethods module,
+    # which will be deprecated in RuboCop 2.0.
     module AllowedMethods
       private
 

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

@@ -47,7 +47,7 @@ module RuboCop
         match.captures
       end
 
-      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Layout/ClassStructure, Style/MutableConstant
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
       private_constant :KEYWORDS_REGEX_CACHE
 
       def regex

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

@@ -62,10 +62,12 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type? && node.loc.else
+        if node.if_type? && node.else?
           node.loc.else.line
+        elsif node.if_type? && node.ternary?
+          node.else_branch.loc.line
         elsif (next_sibling = node.right_sibling)
           next_sibling.loc.line
         elsif (parent = node.parent)
@@ -74,7 +76,7 @@ module RuboCop
           node.loc.end.line
         end
       end
-      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     end
   end
 end

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

@@ -3,6 +3,7 @@
 module RuboCop
   module Cop
     # This module checks for Ruby 3.1's hash value omission syntax.
+    # rubocop:disable Metrics/ModuleLength
     module HashShorthandSyntax
       OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
       EXPLICIT_HASH_VALUE_MSG = 'Include the hash value.'
@@ -45,21 +46,22 @@ module RuboCop
 
       private
 
-      # rubocop:disable Metrics/AbcSize
-      def register_offense(node, message, replacement)
+      def register_offense(node, message, replacement) # rubocop:disable Metrics/AbcSize
         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,
+            last_argument = def_node.last_argument
+            if last_argument.nil? || !last_argument.hash_type?
+              next corrector.replace(node, replacement)
+            end
+
+            white_spaces = range_between(def_node.selector.end_pos,
                                          def_node.first_argument.source_range.begin_pos)
             corrector.replace(white_spaces, '(')
-
-            last_argument = def_node.arguments.last
             corrector.insert_after(last_argument, ')') if node == last_argument.pairs.last
           end
           corrector.replace(node, replacement)
         end
       end
-      # rubocop:enable Metrics/AbcSize
 
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
@@ -86,25 +88,37 @@ module RuboCop
       end
 
       def require_hash_value_for_around_hash_literal?(node)
-        return false unless (send_node = find_ancestor_send_node(node))
+        return false unless (method_dispatch_node = find_ancestor_method_dispatch_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)
+        !node.parent.braces? &&
+          !use_element_of_hash_literal_as_receiver?(method_dispatch_node, node.parent) &&
+          use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       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)
+        last_pair = node.parent.pairs.last
+        return unless last_pair.key.source == last_pair.value.source
+        return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
+        return if node.respond_to?(:parenthesized?) && !node.parenthesized?
+        return unless last_expression?(dispatch_node) || method_dispatch_as_argument?(dispatch_node)
 
-        def_node = node.each_ancestor(:send, :csend).first
+        def_node = node.each_ancestor(:send, :csend, :super, :yield).first
 
-        def_node unless def_node && def_node.arguments.empty?
+        DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def find_ancestor_send_node(node)
-        ancestor = node.parent.parent
+      def find_ancestor_method_dispatch_node(node)
+        return unless (ancestor = node.parent.parent)
+        return unless ancestor.call_type? || ancestor.super_type? || ancestor.yield_type?
+        return if brackets?(ancestor)
+
+        ancestor
+      end
 
-        ancestor if ancestor&.call_type? && !ancestor&.method?(:[])
+      def brackets?(method_dispatch_node)
+        method_dispatch_node.method?(:[]) || method_dispatch_node.method?(:[]=)
       end
 
       def use_element_of_hash_literal_as_receiver?(ancestor, parent)
@@ -118,15 +132,16 @@ module RuboCop
         ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
-      def without_parentheses_call_expr_follows?(ancestor)
-        return false unless ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized?
+      def last_expression?(ancestor)
+        ancestor.right_sibling ||
+          ancestor.each_ancestor.find { |node| node.assignment? || node.send_type? }&.right_sibling
+      end
 
-        right_sibling = ancestor.right_sibling
-        right_sibling ||= ancestor.each_ancestor.find do |node|
-          node.assignment? || node.send_type?
-        end&.right_sibling
+      def method_dispatch_as_argument?(method_dispatch_node)
+        parent = method_dispatch_node.parent
+        return false unless parent
 
-        !!right_sibling
+        parent.call_type? || parent.super_type? || parent.yield_type?
       end
 
       def breakdown_value_types_of_hash(hash_node)
@@ -182,6 +197,25 @@ module RuboCop
           register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
         end
       end
+
+      DefNode = Struct.new(:node) do
+        def selector
+          if node.loc.respond_to?(:selector)
+            node.loc.selector
+          else
+            node.loc.keyword
+          end
+        end
+
+        def first_argument
+          node.first_argument
+        end
+
+        def last_argument
+          node.last_argument
+        end
+      end
     end
   end
+  # rubocop:enable Metrics/ModuleLength
 end

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Help methods for determining if a line is too long.
     module LineLengthHelp
+      include Alignment
+
       private
 
       def ignore_cop_directives?
@@ -85,7 +87,7 @@ module RuboCop
 
       def tab_indentation_width
         config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
-          config.for_cop('Layout/IndentationWidth')['Width']
+          configured_indentation_width
       end
 
       def uri_regexp

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

@@ -175,7 +175,7 @@ module RuboCop
 
       def remove_optarg_equals(asgn_tokens, processed_source)
         optargs    = processed_source.ast.each_node(:optarg)
-        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+        optarg_eql = optargs.to_set { |o| o.loc.operator.begin_pos }
         asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
       end
     end

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

@@ -5,6 +5,7 @@ module RuboCop
     # Common functionality for modifier cops.
     module StatementModifier
       include LineLengthHelp
+      include RangeHelp
 
       private
 

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

@@ -107,9 +107,9 @@ module RuboCop
         end
       end
 
-      def empty_brackets?(left_bracket_token, right_bracket_token)
-        left_index = processed_source.tokens.index(left_bracket_token)
-        right_index = processed_source.tokens.index(right_bracket_token)
+      def empty_brackets?(left_bracket_token, right_bracket_token, tokens: processed_source.tokens)
+        left_index = tokens.index(left_bracket_token)
+        right_index = tokens.index(right_bracket_token)
         right_index && left_index == right_index - 1
       end
 

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

@@ -132,7 +132,7 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = /array/.match?(kind) ? 'an' : 'a'
+        article = kind.include?('array') ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',

data/lib/rubocop/cop/naming/block_forwarding.rb

@@ -47,6 +47,10 @@ module RuboCop
 
         MSG = 'Use %<style>s block forwarding.'
 
+        def self.autocorrect_incompatible_with
+          [Lint::AmbiguousOperator]
+        end
+
         def on_def(node)
           return if node.arguments.empty?
 

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -34,7 +34,7 @@ module RuboCop
 
           allowed = /#{cop_config['AllowedNames'].join('|')}/
           name = node.loc.name.source.gsub(allowed, '')
-          return unless /_/.match?(name)
+          return unless name.include?('_')
 
           add_offense(node.loc.name)
         end

data/lib/rubocop/cop/registry.rb

@@ -19,6 +19,33 @@ module RuboCop
     class Registry
       include Enumerable
 
+      def self.all
+        global.without_department(:Test).cops
+      end
+
+      def self.qualified_cop_name(name, origin)
+        global.qualified_cop_name(name, origin)
+      end
+
+      # Changes momentarily the global registry
+      # Intended for testing purposes
+      def self.with_temporary_global(temp_global = global.dup)
+        previous = @global
+        @global = temp_global
+        yield
+      ensure
+        @global = previous
+      end
+
+      def self.reset!
+        @global = new
+      end
+
+      def self.qualified_cop?(name)
+        badge = Badge.parse(name)
+        global.qualify_badge(badge).first == badge
+      end
+
       attr_reader :options
 
       def initialize(cops = [], options = {})
@@ -136,6 +163,13 @@ module RuboCop
           'RedundantCopDisableDirective'
       end
 
+      def qualify_badge(badge)
+        clear_enrollment_queue
+        @departments
+          .map { |department, _| badge.with_department(department) }
+          .select { |potential_badge| registered?(potential_badge) }
+      end
+
       # @return [Hash{String => Array<Class>}]
       def to_h
         clear_enrollment_queue
@@ -238,28 +272,6 @@ module RuboCop
         attr_reader :global
       end
 
-      def self.all
-        global.without_department(:Test).cops
-      end
-
-      def self.qualified_cop_name(name, origin)
-        global.qualified_cop_name(name, origin)
-      end
-
-      # Changes momentarily the global registry
-      # Intended for testing purposes
-      def self.with_temporary_global(temp_global = global.dup)
-        previous = @global
-        @global = temp_global
-        yield
-      ensure
-        @global = previous
-      end
-
-      def self.reset!
-        @global = new
-      end
-
       private
 
       def initialize_copy(reg)
@@ -282,13 +294,6 @@ module RuboCop
         self.class.new(cops)
       end
 
-      def qualify_badge(badge)
-        clear_enrollment_queue
-        @departments
-          .map { |department, _| badge.with_department(department) }
-          .select { |potential_badge| registered?(potential_badge) }
-      end
-
       def resolve_badge(given_badge, real_badge, source_path)
         unless given_badge.match?(real_badge)
           path = PathUtil.smart_path(source_path)

data/lib/rubocop/cop/security/compound_hash.rb

@@ -9,7 +9,8 @@ module RuboCop
       # Manually combining hashes is error prone and hard to follow, especially
       # when there are many values. Poor implementations may also introduce
       # performance or security concerns if they are prone to collisions.
-      # Delegating to `Array#hash` is clearer, faster, and safer.
+      # Delegating to `Array#hash` is clearer and safer, although it might be slower
+      # depending on the use case.
       #
       # @safety
       #   This cop may be unsafe if the application logic depends on the hash

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

@@ -115,9 +115,7 @@ module RuboCop
             def_node = find_corresponding_def_node(node)
             return unless def_node
 
-            remove_node(corrector, def_node)
-            remove_node(corrector, node)
-            insert_def(corrector, node, def_node.source)
+            replace_def(corrector, node, def_node)
           when :inline
             remove_node(corrector, node)
             select_grouped_def_nodes(node).each do |grouped_def_node|
@@ -131,7 +129,8 @@ module RuboCop
         end
 
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node)) ||
+          (group_style? && access_modifier_is_inlined?(node) &&
+            !right_siblings_same_inline_method?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
         end
 
@@ -151,6 +150,12 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
+        def right_siblings_same_inline_method?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.send_type? && sibling.method?(node.method_name) && !sibling.arguments.empty?
+          end
+        end
+
         def message(range)
           access_modifier = range.source
 
@@ -173,7 +178,9 @@ module RuboCop
         end
 
         def find_argument_less_modifier_node(node)
-          node.parent.each_child_node(:send).find do |child|
+          return unless (parent = node.parent)
+
+          parent.each_child_node(:send).find do |child|
             child.method?(node.method_name) && child.arguments.empty?
           end
         end
@@ -184,17 +191,21 @@ module RuboCop
           end.select(&:def_type?)
         end
 
-        def insert_def(corrector, node, source)
-          source = [*processed_source.ast_with_comments[node].map(&:text), source].join("\n")
+        def replace_def(corrector, node, def_node)
+          source = def_source(node, def_node)
           argument_less_modifier_node = find_argument_less_modifier_node(node)
           if argument_less_modifier_node
             corrector.insert_after(argument_less_modifier_node, "\n\n#{source}")
+          elsif (ancestor = node.each_ancestor(:block, :class, :module).first)
+
+            corrector.insert_before(ancestor.loc.end, "#{node.method_name}\n\n#{source}\n")
           else
-            corrector.insert_before(
-              node.each_ancestor(:block, :class, :module).first.location.end,
-              "#{node.method_name}\n\n#{source}\n"
-            )
+            corrector.replace(node, "#{node.method_name}\n\n#{source}")
+            return
           end
+
+          remove_node(corrector, def_node)
+          remove_node(corrector, node)
         end
 
         def insert_inline_modifier(corrector, node, modifier_name)
@@ -204,6 +215,10 @@ module RuboCop
         def remove_node(corrector, node)
           corrector.remove(range_with_comments_and_lines(node))
         end
+
+        def def_source(node, def_node)
+          [*processed_source.ast_with_comments[node].map(&:text), def_node.source].join("\n")
+        end
       end
     end
   end

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

@@ -84,6 +84,7 @@ module RuboCop
         def on_def(node)
           return unless node.body
           return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+          return if args.any?(&:default?)
 
           node.each_descendant(:send) do |send_node|
             kwargs_name, block_name = extract_argument_names_from(args)

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

@@ -32,7 +32,7 @@ module RuboCop
               eq_begin, eq_end, contents = parts(comment)
 
               corrector.remove(eq_begin)
-              unless contents.length.zero?
+              unless contents.empty?
                 corrector.replace(
                   contents,
                   contents.source.gsub(/\A/, '# ').gsub(/\n\n/, "\n#\n").gsub(/\n(?=[^#])/, "\n# ")