rubocop 1.41.1 → 1.57.1

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def separator_delta(pair)
           if pair.hash_rocket?
-            correct_separator_column = pair.key.loc.expression.end.column + 1
+            correct_separator_column = pair.key.source_range.end.column + 1
             actual_separator_column = pair.loc.operator.column
 
             correct_separator_column - actual_separator_column

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,39 @@ 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 dispatch_node.assignment_method?
+        return if dispatch_node.parenthesized?
+        return if dispatch_node.parent && parentheses?(dispatch_node.parent)
+        return if 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 +134,19 @@ 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?(node)
+        return false if node.right_sibling
+        return true unless (assignment_node = node.each_ancestor.find(&:assignment?))
+        return last_expression?(assignment_node.parent) if assignment_node.parent&.assignment?
 
-        right_sibling = ancestor.right_sibling
-        right_sibling ||= ancestor.each_ancestor.find do |node|
-          node.assignment? || node.send_type?
-        end&.right_sibling
+        !assignment_node.right_sibling
+      end
+
+      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 +202,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/hash_transform_method.rb

@@ -159,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
@@ -175,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/heredoc.rb

@@ -26,11 +26,15 @@ module RuboCop
       end
 
       def delimiter_string(node)
-        node.source.match(OPENING_DELIMITER).captures[1]
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[1]
       end
 
       def heredoc_type(node)
-        node.source.match(OPENING_DELIMITER).captures[0]
+        return '' unless (match = node.source.match(OPENING_DELIMITER))
+
+        match.captures[0]
       end
     end
   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/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_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

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

@@ -20,16 +20,17 @@ module RuboCop
         range = offending_range(node, lhs, rhs, style)
         check(range, node, lhs, rhs)
       end
+      alias on_csend on_send
 
       private
 
-      # In a chain of method calls, we regard the top send node as the base
+      # In a chain of method calls, we regard the top call node as the base
       # for indentation of all lines following the first. For example:
       # a.
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        while lhs.parent&.send_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
+        while lhs.parent&.call_type? && lhs.parent.loc.dot && !lhs.parent.assignment_method?
           lhs = lhs.parent
         end
         lhs

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_literal.rb

@@ -9,7 +9,7 @@ module RuboCop
       private
 
       def percent_literal?(node)
-        return unless (begin_source = begin_source(node))
+        return false unless (begin_source = begin_source(node))
 
         begin_source.start_with?('%')
       end

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

@@ -75,9 +75,7 @@ module RuboCop
       end
 
       def aligned_token?(range, line)
-        aligned_words?(range, line) ||
-          aligned_char?(range, line) ||
-          aligned_assignment?(range, line)
+        aligned_words?(range, line) || aligned_assignment?(range, line)
       end
 
       def aligned_operator?(range, line)
@@ -85,11 +83,11 @@ module RuboCop
       end
 
       def aligned_words?(range, line)
-        /\s\S/.match?(line[range.column - 1, 2])
-      end
+        left_edge = range.column
+        return true if /\s\S/.match?(line[left_edge - 1, 2])
 
-      def aligned_char?(range, line)
-        line[range.column] == range.source[0]
+        token = range.source
+        token == line[left_edge, token.length]
       end
 
       def aligned_assignment?(range, line)
@@ -175,7 +173,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

@@ -132,12 +132,7 @@ module RuboCop
       end
 
       def range_with_comments(node)
-        ranges = [
-          node,
-          *@processed_source.ast_with_comments[node]
-        ].map do |element|
-          element.location.expression
-        end
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
         ranges.reduce do |result, range|
           add_range(result, range)
         end

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
 
@@ -64,14 +65,14 @@ module RuboCop
       end
 
       def method_source(if_body)
-        range_between(if_body.loc.expression.begin_pos, if_body.loc.selector.end_pos).source
+        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/string_help.rb

@@ -30,8 +30,10 @@ module RuboCop
       private
 
       def inside_interpolation?(node)
-        # A :begin node inside a :dstr node is an interpolation.
-        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
+        # A :begin node inside a :dstr, :dsym, or :regexp node is an interpolation.
+        node.ancestors
+            .drop_while { |a| !a.begin_type? }
+            .any? { |a| a.dstr_type? || a.dsym_type? || a.regexp_type? }
       end
     end
   end

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

@@ -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.
@@ -106,7 +106,7 @@ module RuboCop
       end
 
       def elements(node)
-        return node.children unless %i[csend send].include?(node.type)
+        return node.children unless node.call_type?
 
         node.arguments.flat_map do |argument|
           # For each argument, if it is a multi-line hash without braces,
@@ -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/ascii_identifiers.rb

@@ -57,7 +57,7 @@ module RuboCop
         CONSTANT_MSG   = 'Use only ascii symbols in constants.'
 
         def on_new_investigation
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             next if !should_check?(token) || token.text.ascii_only?
 
             message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG

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?
 
@@ -105,7 +109,7 @@ module RuboCop
         end
 
         def use_block_argument_as_local_variable?(node, last_argument)
-          return if node.body.nil?
+          return false if node.body.nil?
 
           node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
             !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument

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/naming/constant_name.rb

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def contains_constant?(node)
-          node.branches.any?(&:const_type?)
+          node.branches.compact.any?(&:const_type?)
         end
       end
     end

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

@@ -136,7 +136,7 @@ module RuboCop
         end
 
         def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
+          basename = basename.delete_prefix('.')
           basename = basename.sub(/\.[^.]+$/, '')
           # special handling for Action Pack Variants file names like
           # some_file.xlsx+mobile.axlsx

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

@@ -38,7 +38,7 @@ module RuboCop
           return if correct_case_delimiters?(node)
 
           add_offense(node.loc.heredoc_end) do |corrector|
-            expr = node.loc.expression
+            expr = node.source_range
 
             corrector.replace(expr, correct_delimiters(expr.source))
             corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))

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

@@ -31,7 +31,9 @@ module RuboCop
         def on_heredoc(node)
           return if meaningful_delimiters?(node)
 
-          add_offense(node.loc.heredoc_end)
+          range = node.children.empty? ? node : node.loc.heredoc_end
+
+          add_offense(range)
         end
 
         private

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

@@ -5,6 +5,7 @@ module RuboCop
     module Naming
       # Recommends the use of inclusive language instead of problematic terms.
       # The cop can check the following locations for offenses:
+      #
       # - identifiers
       # - constants
       # - variables
@@ -12,6 +13,7 @@ module RuboCop
       # - symbols
       # - comments
       # - file paths
+      #
       # Each of these locations can be individually enabled/disabled via configuration,
       # for example CheckIdentifiers = true/false.
       #
@@ -22,6 +24,9 @@ module RuboCop
       # `WholeWord: true` can be set on a flagged term to indicate the cop should only match when
       # a term matches the whole word (partial matches will not be offenses).
       #
+      # The cop supports autocorrection when there is only one suggestion. When there are multiple
+      # suggestions, the best suggestion cannot be identified and will not be autocorrected.
+      #
       # @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }
       #   # Suggest replacing identifier whitelist with allowlist
       #
@@ -68,6 +73,7 @@ module RuboCop
       #   TeslaVehicle
       class InclusiveLanguage < Base
         include RangeHelp
+        extend AutoCorrector
 
         EMPTY_ARRAY = [].freeze
         MSG = "Consider replacing '%<term>s'%<suffix>s."
@@ -92,7 +98,7 @@ module RuboCop
         private
 
         def investigate_tokens
-          processed_source.each_token do |token|
+          processed_source.tokens.each do |token|
             next unless check_token?(token.type)
 
             word_locations = scan_for_words(token.text)
@@ -104,9 +110,16 @@ module RuboCop
 
         def add_offenses_for_token(token, word_locations)
           word_locations.each do |word_location|
-            start_position = token.pos.begin_pos + token.pos.source.index(word_location.word)
-            range = range_between(start_position, start_position + word_location.word.length)
-            add_offense(range, message: create_message(word_location.word))
+            word = word_location.word
+            range = offense_range(token, word)
+
+            add_offense(range, message: create_message(word)) do |corrector|
+              suggestions = find_flagged_term(word)['Suggestions']
+
+              next unless suggestions.is_a?(String)
+
+              corrector.replace(range, suggestions)
+            end
           end
         end
 
@@ -264,6 +277,12 @@ module RuboCop
                            end
           " with #{suggestion_str}"
         end
+
+        def offense_range(token, word)
+          start_position = token.pos.begin_pos + token.pos.source.index(word)
+
+          range_between(start_position, start_position + word.length)
+        end
       end
     end
   end