rubocop 1.31.2 → 1.57.1

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/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

@@ -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.
@@ -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/mixin/visibility_help.rb

@@ -1,18 +1,43 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module RuboCop
   module Cop
     # Help methods for determining node visibility.
     module VisibilityHelp
       extend NodePattern::Macros
 
-      VISIBILITY_SCOPES = %i[private protected public].freeze
+      VISIBILITY_SCOPES = ::Set[:private, :protected, :public].freeze
 
       private
 
       def node_visibility(node)
-        scope = find_visibility_start(node)
-        scope&.method_name || :public
+        node_visibility_from_visibility_inline(node) ||
+          node_visibility_from_visibility_block(node) ||
+          :public
+      end
+
+      def node_visibility_from_visibility_inline(node)
+        return unless node.def_type?
+
+        node_visibility_from_visibility_inline_on_def(node) ||
+          node_visibility_from_visibility_inline_on_method_name(node)
+      end
+
+      def node_visibility_from_visibility_inline_on_def(node)
+        parent = node.parent
+        parent.method_name if visibility_inline_on_def?(parent)
+      end
+
+      def node_visibility_from_visibility_inline_on_method_name(node)
+        node.right_siblings.reverse.find do |sibling|
+          visibility_inline_on_method_name?(sibling, method_name: node.method_name)
+        end&.method_name
+      end
+
+      def node_visibility_from_visibility_block(node)
+        find_visibility_start(node)&.method_name
       end
 
       def find_visibility_start(node)
@@ -21,7 +46,7 @@ module RuboCop
 
       # Navigate to find the last protected method
       def find_visibility_end(node)
-        possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+        possible_visibilities = VISIBILITY_SCOPES - ::Set[node_visibility(node)]
         right = node.right_siblings
         right.find do |child_node|
           possible_visibilities.include?(node_visibility(child_node))
@@ -30,7 +55,17 @@ module RuboCop
 
       # @!method visibility_block?(node)
       def_node_matcher :visibility_block?, <<~PATTERN
-        (send nil? { :private :protected :public })
+        (send nil? VISIBILITY_SCOPES)
+      PATTERN
+
+      # @!method visibility_inline_on_def?(node)
+      def_node_matcher :visibility_inline_on_def?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES def)
+      PATTERN
+
+      # @!method visibility_inline_on_method_name?(node, method_name:)
+      def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES (sym %method_name))
       PATTERN
     end
   end

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,10 +109,10 @@ 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.source == last_argument
+            !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
           end
         end
 

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

@@ -38,7 +38,7 @@ module RuboCop
       class BlockParameterName < Base
         include UncommunicativeName
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.arguments?
 
           check(node, node.arguments)

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

@@ -30,9 +30,11 @@ module RuboCop
         MSG = 'Use CamelCase for classes and modules.'
 
         def on_class(node)
+          return unless node.loc.name.source.include?('_')
+
           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

@@ -72,11 +72,11 @@ module RuboCop
         PATTERN
 
         def allowed_conditional_expression_on_rhs?(node)
-          node&.if_type? && contains_contant?(node)
+          node&.if_type? && contains_constant?(node)
         end
 
-        def contains_contant?(node)
-          node.branches.any?(&:const_type?)
+        def contains_constant?(node)
+          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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Naming
-      # This cops recommends the use of inclusive language instead of problematic terms.
+      # 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
 
@@ -207,7 +220,10 @@ module RuboCop
         end
 
         def scan_for_words(input)
-          mask_input(input).enum_for(:scan, @flagged_terms_regex).map do
+          masked_input = mask_input(input)
+          return EMPTY_ARRAY unless masked_input.match?(@flagged_terms_regex)
+
+          masked_input.enum_for(:scan, @flagged_terms_regex).map do
             match = Regexp.last_match
             WordLocation.new(match.to_s, match.offset(0).first)
           end
@@ -261,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

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

@@ -17,7 +17,8 @@ module RuboCop
       # @safety
       #   This cop relies on the pattern `@instance_var ||= ...`,
       #   but this is sometimes used for other purposes than memoization
-      #   so this cop is considered unsafe.
+      #   so this cop is considered unsafe. Also, its autocorrection is unsafe
+      #   because it may conflict with instance variable names already in use.
       #
       # @example EnforcedStyleForLeadingUnderscores: disallowed (default)
       #   # bad
@@ -145,6 +146,8 @@ module RuboCop
       #     @_foo ||= calculate_expensive_thing
       #   end
       class MemoizedInstanceVariableName < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
 
         MSG = 'Memoized variable `%<var>s` does not match ' \
@@ -163,6 +166,7 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
         def on_or_asgn(node)
           lhs, _value = *node
           return unless lhs.ivasgn_type?
@@ -175,14 +179,18 @@ module RuboCop
 
           return if matches?(method_name, lhs)
 
+          suggested_var = suggested_var(method_name)
           msg = format(
             message(lhs.children.first.to_s),
             var: lhs.children.first.to_s,
-            suggested_var: suggested_var(method_name),
+            suggested_var: suggested_var,
             method: method_name
           )
-          add_offense(lhs, message: msg)
+          add_offense(lhs, message: msg) do |corrector|
+            corrector.replace(lhs.loc.name, "@#{suggested_var}")
+          end
         end
+        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -196,24 +204,31 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
           arg = node.arguments.first
-          return unless arg.ivar_type?
+          return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)
-          return unless method_node
+          return false unless method_node
 
           var_name = arg.children.first
           defined_memoized?(method_node.body, var_name) do |defined_ivar, return_ivar, ivar_assign|
-            return if matches?(method_name, ivar_assign)
+            return false if matches?(method_name, ivar_assign)
 
+            suggested_var = suggested_var(method_name)
             msg = format(
               message(var_name.to_s),
               var: var_name.to_s,
-              suggested_var: suggested_var(method_name),
+              suggested_var: suggested_var,
               method: method_name
             )
-            add_offense(defined_ivar, message: msg)
-            add_offense(return_ivar, message: msg)
-            add_offense(ivar_assign.loc.name, message: msg)
+            add_offense(defined_ivar, message: msg) do |corrector|
+              corrector.replace(defined_ivar, "@#{suggested_var}")
+            end
+            add_offense(return_ivar, message: msg) do |corrector|
+              corrector.replace(return_ivar, "@#{suggested_var}")
+            end
+            add_offense(ivar_assign.loc.name, message: msg) do |corrector|
+              corrector.replace(ivar_assign.loc.name, "@#{suggested_var}")
+            end
           end
         end
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength

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

@@ -10,8 +10,8 @@ module RuboCop
       #
       #   Naming/MethodName:
       #     AllowedPatterns:
-      #       - '\A\s*onSelectionBulkChange\s*'
-      #       - '\A\s*onSelectionCleared\s*'
+      #       - '\AonSelectionBulkChange\z'
+      #       - '\AonSelectionCleared\z'
       #
       # Method names matching patterns are always allowed.
       #
@@ -67,7 +67,7 @@ module RuboCop
 
         def range_position(node)
           selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.loc.expression.end_pos
+          expr_end_pos = node.source_range.end_pos
 
           range_between(selector_end_pos, expr_end_pos)
         end

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

@@ -3,7 +3,30 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that predicates are named properly.
+      # Checks that predicate methods names end with a question mark and
+      # do not start with a forbidden prefix.
+      #
+      # A method is determined to be a predicate method if its name starts
+      # with one of the prefixes defined in the `NamePrefix` configuration.
+      # You can change what prefixes are considered by changing this option.
+      # Any method name that starts with one of these prefixes is required by
+      # the cop to end with a `?`. Other methods can be allowed by adding to
+      # the `AllowedMethods` configuration.
+      #
+      # NOTE: The `is_a?` method is allowed by default.
+      #
+      # If `ForbiddenPrefixes` is set, methods that start with the configured
+      # prefixes will not be allowed and will be removed by autocorrection.
+      #
+      # In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo`
+      # will register an offense only due to the lack of question mark (and will be
+      # autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`,
+      # `is_foo` will register an offense both because the ? is missing and because of
+      # the `is_` prefix, and will be corrected to `foo?`.
+      #
+      # NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`;
+      # a prefix in the former but not the latter will not be considered by
+      # this cop.
       #
       # @example
       #   # bad
@@ -27,6 +50,12 @@ module RuboCop
       #   # good
       #   def value?
       #   end
+      #
+      # @example AllowedMethods: ['is_a?'] (default)
+      #   # good
+      #   def is_a?(value)
+      #   end
+      #
       class PredicateName < Base
         include AllowedMethods
 
@@ -43,7 +72,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.loc.expression,
+                node.first_argument.source_range,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end

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

@@ -82,9 +82,7 @@ module RuboCop
           message = message(node)
 
           add_offense(range, message: message) do |corrector|
-            corrector.replace(range, preferred_name)
-
-            correct_node(corrector, node.body, offending_name, preferred_name)
+            autocorrect(corrector, node, range, offending_name, preferred_name)
           end
         end
 
@@ -92,7 +90,17 @@ module RuboCop
 
         def offense_range(resbody)
           variable = resbody.exception_variable
-          variable.loc.expression
+          variable.source_range
+        end
+
+        def autocorrect(corrector, node, range, offending_name, preferred_name)
+          corrector.replace(range, preferred_name)
+          correct_node(corrector, node.body, offending_name, preferred_name)
+          return unless (kwbegin_node = node.parent.each_ancestor(:kwbegin).first)
+
+          kwbegin_node.right_siblings.each do |child_node|
+            correct_node(corrector, child_node, offending_name, preferred_name)
+          end
         end
 
         def variable_name_matches?(node, name)

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

@@ -20,9 +20,14 @@ module RuboCop
       #   # good
       #   fooBar = 1
       #
+      # @example AllowedIdentifiers: ['fooBar']
+      #   # good (with EnforcedStyle: snake_case)
+      #   fooBar = 1
+      #
       # @example AllowedPatterns: ['_v\d+\z']
-      #   # good
+      #   # good (with EnforcedStyle: camelCase)
       #   :release_v1
+      #
       class VariableName < Base
         include AllowedIdentifiers
         include ConfigurableNaming