rubocop 1.31.1 → 1.52.1

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

@@ -14,7 +14,7 @@ module RuboCop
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
       PATTERN
 
-      def on_block(node)
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
@@ -68,6 +68,8 @@ module RuboCop
         # `transform_values` if value transformation uses key.
         return if captures.transformation_uses_both_args?
 
+        return unless captures.use_transformed_argname?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)
@@ -113,11 +115,7 @@ module RuboCop
       end
 
       # Internal helper class to hold match data
-      Captures = Struct.new(
-        :transformed_argname,
-        :transforming_body_expr,
-        :unchanged_body_expr
-      ) do
+      Captures = Struct.new(:transformed_argname, :transforming_body_expr, :unchanged_body_expr) do
         def noop_transformation?
           transforming_body_expr.lvar_type? &&
             transforming_body_expr.children == [transformed_argname]
@@ -126,6 +124,12 @@ module RuboCop
         def transformation_uses_both_args?
           transforming_body_expr.descendants.include?(unchanged_body_expr)
         end
+
+        def use_transformed_argname?
+          transforming_body_expr.each_descendant(:lvar).any? do |node|
+            node.source == transformed_argname.to_s
+          end
+        end
       end
 
       # Internal helper class to hold autocorrect data
@@ -155,7 +159,7 @@ module RuboCop
         end
 
         def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
+          expression = node.source_range
           corrector.remove_leading(expression, leading)
           corrector.remove_trailing(expression, trailing)
         end
@@ -171,11 +175,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
+          corrector.replace(block_node.arguments, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.loc.expression.source
+          body_source = transforming_body_expr.source
           if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
             body_source = "{ #{body_source} }"
           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?
@@ -57,7 +59,14 @@ module RuboCop
       def indentation_difference(line)
         return 0 unless tab_indentation_width
 
-        (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
+        index =
+          if line.match?(/^[^\t]/)
+            0
+          else
+            line.index(/[^\t]/) || 0
+          end
+
+        index * (tab_indentation_width - 1)
       end
 
       def extend_uri_end_position(line, end_position)
@@ -78,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/method_complexity.rb

@@ -6,21 +6,16 @@ module RuboCop
     #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include IgnoredMethods
+      include AllowedMethods
+      include AllowedPattern
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
       extend ExcludeLimit
 
       exclude_limit 'Max'
 
-      # Ensure cops that include `MethodComplexity` have the config
-      # `attr_accessor`s that `ignored_method?` needs.
-      def self.included(base)
-        base.extend(IgnoredMethods::Config)
-      end
-
       def on_def(node)
-        return if ignored_method?(node.method_name)
+        return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
         check_complexity(node, node.method_name)
       end
@@ -28,20 +23,20 @@ module RuboCop
 
       def on_block(node)
         define_method?(node) do |name|
-          return if ignored_method?(name)
+          return if allowed_method?(name) || matches_allowed_pattern?(name)
 
           check_complexity(node, name)
         end
       end
 
+      alias on_numblock on_block
+
       private
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        (block
-         (send nil? :define_method ({sym str} $_))
-         args
-         _)
+        ({block numblock}
+         (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 
       def check_complexity(node, method_name)
@@ -64,13 +59,15 @@ module RuboCop
       end
 
       def complexity(body)
-        body.each_node(:lvasgn, *self.class::COUNTED_NODES).reduce(1) do |score, node|
+        score = 1
+        body.each_node(:lvasgn, *self.class::COUNTED_NODES) do |node|
           if node.lvasgn_type?
             reset_on_lvasgn(node)
-            next score
+          else
+            score += complexity_score_for(node)
           end
-          score + complexity_score_for(node)
         end
+        score
       end
     end
   end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking minimum branches count.
+    module MinBranchesCount
+      private
+
+      def min_branches_count?(node)
+        branches =
+          if node.case_type?
+            node.when_branches
+          elsif node.if_type?
+            if_conditional_branches(node)
+          else
+            raise ArgumentError, "Unsupported #{node.type.inspect} node type"
+          end
+
+        branches.size >= min_branches_count
+      end
+
+      def min_branches_count
+        length = cop_config['MinBranchesCount'] || 3
+        return length if length.is_a?(Integer) && length.positive?
+
+        raise 'MinBranchesCount needs to be a positive integer!'
+      end
+
+      def if_conditional_branches(node, branches = [])
+        return [] if node.nil? || !node.if_type?
+
+        branches << node.if_branch
+
+        else_branch = node.else_branch
+        if_conditional_branches(else_branch, branches) if else_branch&.if_type?
+        branches
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ module RuboCop
       def check_first(first, left_brace, left_parenthesis, offset)
         actual_column = first.source_range.column
 
-        indent_base_column, indent_base_type = indent_base(left_brace, left_parenthesis)
+        indent_base_column, indent_base_type = indent_base(left_brace, first, left_parenthesis)
         expected_column = indent_base_column + configured_indentation_width + offset
 
         @column_delta = expected_column - actual_column
@@ -47,33 +47,26 @@ module RuboCop
         end
       end
 
-      def indent_base(left_brace, left_parenthesis)
+      def indent_base(left_brace, first, left_parenthesis)
         return [left_brace.column, :left_brace_or_bracket] if style == brace_alignment_style
 
-        pair = hash_pair_where_value_beginning_with(left_brace)
+        pair = hash_pair_where_value_beginning_with(left_brace, first)
         if pair && key_and_value_begin_on_same_line?(pair) &&
            right_sibling_begins_on_subsequent_line?(pair)
           return [pair.loc.column, :parent_hash_key]
         end
 
         if left_parenthesis && style == :special_inside_parentheses
-          return [left_parenthesis.column + 1, :first_colmn_after_left_parenthesis]
+          return [left_parenthesis.column + 1, :first_column_after_left_parenthesis]
         end
 
         [left_brace.source_line =~ /\S/, :start_of_line]
       end
 
-      def hash_pair_where_value_beginning_with(left_brace)
-        node = node_beginning_with(left_brace)
-        node.parent&.pair_type? ? node.parent : nil
-      end
+      def hash_pair_where_value_beginning_with(left_brace, first)
+        return unless first && first.parent.loc.begin == left_brace
 
-      def node_beginning_with(left_brace)
-        processed_source.ast.each_descendant do |node|
-          if node.loc.is_a?(Parser::Source::Map::Collection) && (node.loc.begin == left_brace)
-            break node
-          end
-        end
+        first.parent&.parent&.pair_type? ? first.parent.parent : nil
       end
 
       def key_and_value_begin_on_same_line?(pair)

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# TEAM: backend_infra
-# WATCHERS: maxh
-
 module RuboCop
   module Cop
     # Common functionality for checking for a line break before each
@@ -10,8 +7,8 @@ module RuboCop
     module MultilineElementLineBreaks
       private
 
-      def check_line_breaks(_node, children)
-        return if all_on_same_line?(children)
+      def check_line_breaks(_node, children, ignore_last: false)
+        return if all_on_same_line?(children, ignore_last: ignore_last)
 
         last_seen_line = -1
         children.each do |child|
@@ -23,9 +20,11 @@ module RuboCop
         end
       end
 
-      def all_on_same_line?(nodes)
+      def all_on_same_line?(nodes, ignore_last: false)
         return true if nodes.empty?
 
+        return same_line?(nodes.first, nodes.last) if ignore_last
+
         nodes.first.first_line == nodes.last.last_line
       end
     end

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

@@ -10,7 +10,7 @@ module RuboCop
       def get_source_range(node, comments_as_separators)
         unless comments_as_separators
           first_comment = processed_source.ast_with_comments[node].first
-          return first_comment.loc.expression unless first_comment.nil?
+          return first_comment.source_range unless first_comment.nil?
         end
         node.source_range
       end

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

@@ -44,13 +44,26 @@ module RuboCop
         no_acceptable_style! if brackets_required
 
         bracketed_array = build_bracketed_array(node)
-        message = format(self.class::ARRAY_MSG, prefer: bracketed_array)
+        message = build_message_for_bracketed_array(bracketed_array)
 
         add_offense(node, message: message) do |corrector|
           corrector.replace(node, bracketed_array)
         end
       end
 
+      # @param [String] preferred_array_code
+      # @return [String]
+      def build_message_for_bracketed_array(preferred_array_code)
+        format(
+          self.class::ARRAY_MSG,
+          prefer: if preferred_array_code.include?("\n")
+                    'an array literal `[...]`'
+                  else
+                    "`#{preferred_array_code}`"
+                  end
+        )
+      end
+
       def check_bracketed_array(node, literal_prefix)
         return if allowed_bracket_array?(node)
 
@@ -63,6 +76,50 @@ module RuboCop
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end
       end
+
+      # @param [RuboCop::AST::ArrayNode] node
+      # @param [Array<String>] elements
+      # @return [String]
+      def build_bracketed_array_with_appropriate_whitespace(elements:, node:)
+        [
+          '[',
+          whitespace_leading(node),
+          elements.join(",#{whitespace_between(node)}"),
+          whitespace_trailing(node),
+          ']'
+        ].join
+      end
+
+      # Provides whitespace between elements for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #         ^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_between(node)
+        if node.children.length >= 2
+          node.children[0].source_range.end.join(node.children[1].source_range.begin).source
+        else
+          ' '
+        end
+      end
+
+      # Provides leading whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #      ^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_leading(node)
+        node.loc.begin.end.join(node.children[0].source_range.begin).source
+      end
+
+      # Provides trailing whitespace for building a bracketed array.
+      #   %w[  a   b   c    ]
+      #                 ^^^^
+      # @param [RuboCop::AST::ArrayNode] node
+      # @return [String]
+      def whitespace_trailing(node)
+        node.children[-1].source_range.end.join(node.loc.end.begin).source
+      end
     end
   end
 end

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/range_help.rb

@@ -54,11 +54,11 @@ module RuboCop
       NOT_GIVEN = Module.new
       def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
                                        range: NOT_GIVEN, side: :both, newlines: true,
-                                       whitespace: false, continuations: false)
+                                       whitespace: false, continuations: false,
+                                       buffer: @processed_source.buffer)
 
         range = range_positional unless range_positional == NOT_GIVEN
 
-        buffer = @processed_source.buffer
         src = buffer.source
 
         go_left, go_right = directions(side)
@@ -70,9 +70,8 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def range_by_whole_lines(range, include_final_newline: false)
-        buffer = @processed_source.buffer
-
+      def range_by_whole_lines(range, include_final_newline: false,
+                               buffer: @processed_source.buffer)
         last_line = buffer.source_line(range.last_line)
         end_offset = last_line.length - range.last_column
         end_offset += 1 if include_final_newline
@@ -127,6 +126,24 @@ module RuboCop
         pos += size * step while condition && src[pos + offset, size] == needle
         pos.negative? ? 0 : pos
       end
+
+      def range_with_comments_and_lines(node)
+        range_by_whole_lines(range_with_comments(node), include_final_newline: true)
+      end
+
+      def range_with_comments(node)
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
+        ranges.reduce do |result, range|
+          add_range(result, range)
+        end
+      end
+
+      def add_range(range1, range2)
+        range1.with(
+          begin_pos: [range1.begin_pos, range2.begin_pos].min,
+          end_pos: [range1.end_pos, range2.end_pos].max
+        )
+      end
     end
   end
 end

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

@@ -7,6 +7,8 @@ module RuboCop
     module RequireLibrary
       extend NodePattern::Macros
 
+      RESTRICT_ON_SEND = [:require].freeze
+
       def ensure_required(corrector, node, library_name)
         node = node.parent while node.parent&.parent?
 

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

@@ -4,14 +4,16 @@ module RuboCop
   module Cop
     # Common functionality for checking `rescue` nodes.
     module RescueNode
-      def on_new_investigation
-        @modifier_locations = processed_source.tokens.select(&:rescue_modifier?).map(&:pos)
+      def modifier_locations
+        @modifier_locations ||= processed_source.tokens.select(&:rescue_modifier?).map!(&:pos)
       end
 
       private
 
       def rescue_modifier?(node)
-        node&.resbody_type? && @modifier_locations.include?(node.loc.keyword)
+        return false unless node.respond_to?(:resbody_type?)
+
+        node.resbody_type? && modifier_locations.include?(node.loc.keyword)
       end
 
       # @deprecated Use ResbodyNode#exceptions instead

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

@@ -36,7 +36,7 @@ module RuboCop
       end
 
       def allowed_type?(token)
-        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
+        %i[tRPAREN tRBRACK tPIPE tSTRING_DEND].include?(token.type)
       end
 
       def space_forbidden_before_rcurly?

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
 
@@ -48,16 +49,30 @@ 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.source_range.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) }
+        comment = processed_source.comments.find { |c| same_line?(c, node) }
         return unless comment
 
-        comment_source = comment.loc.expression.source
+        comment_source = comment.source
         comment_source unless comment_disables_cop?(comment_source)
       end
 

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

@@ -13,7 +13,7 @@ module RuboCop
 
       private
 
-      def side_space_range(range:, side:)
+      def side_space_range(range:, side:, include_newlines: false)
         buffer = processed_source.buffer
         src = buffer.source
 
@@ -21,11 +21,11 @@ module RuboCop
         end_pos = range.end_pos
         if side == :left
           end_pos = begin_pos
-          begin_pos = reposition(src, begin_pos, -1)
+          begin_pos = reposition(src, begin_pos, -1, include_newlines: include_newlines)
         end
         if side == :right
           begin_pos = end_pos
-          end_pos = reposition(src, end_pos, 1)
+          end_pos = reposition(src, end_pos, 1, include_newlines: include_newlines)
         end
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
@@ -75,9 +75,10 @@ module RuboCop
         end
       end
 
-      def reposition(src, pos, step)
+      def reposition(src, pos, step, include_newlines: false)
         offset = step == -1 ? -1 : 0
-        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset])
+        pos += step while SINGLE_SPACE_REGEXP.match?(src[pos + offset]) ||
+                          (include_newlines && src[pos + offset] == "\n")
         pos.negative? ? 0 : pos
       end
 
@@ -106,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
 
@@ -117,14 +118,15 @@ module RuboCop
       end
 
       def offending_empty_no_space?(config, left_token, right_token)
-        config == 'no_space' && !no_space_between?(left_token, right_token)
+        config == 'no_space' && !no_character_between?(left_token, right_token)
       end
 
       def space_between?(left_bracket_token, right_bracket_token)
-        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos &&
+          processed_source.buffer.source[left_bracket_token.end_pos] == ' '
       end
 
-      def no_space_between?(left_bracket_token, right_bracket_token)
+      def no_character_between?(left_bracket_token, right_bracket_token)
         left_bracket_token.end_pos == right_bracket_token.begin_pos
       end
     end

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

@@ -75,7 +75,7 @@ module RuboCop
 
       def inside_comment?(range, comma_offset)
         comment = processed_source.comment_at_line(range.line)
-        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
+        comment && comment.source_range.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.
@@ -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',