rubocop 1.35.1 → 1.37.0

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

@@ -3,7 +3,7 @@
 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

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

@@ -9,6 +9,11 @@ module RuboCop
       # Applications of visibility methods to symbols can be controlled
       # using AllowModifiersOnSymbols config.
       #
+      # @safety
+      #   Autocorrection is not safe, because the visibility of dynamically
+      #   defined methods can vary depending on the state determined by
+      #   the group access modifier.
+      #
       # @example EnforcedStyle: group (default)
       #   # bad
       #   class Foo
@@ -63,7 +68,10 @@ module RuboCop
       #
       #   end
       class AccessModifierDeclarations < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         GROUP_STYLE_MESSAGE = [
           '`%<access_modifier>s` should not be',
@@ -88,7 +96,10 @@ module RuboCop
           return if allow_modifiers_on_symbols?(node)
 
           if offense?(node)
-            add_offense(node.loc.selector) { opposite_style_detected }
+            add_offense(node.loc.selector) do |corrector|
+              autocorrect(corrector, node)
+            end
+            opposite_style_detected
           else
             correct_style_detected
           end
@@ -96,6 +107,23 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          case style
+          when :group
+            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)
+          when :inline
+            remove_node(corrector, node)
+            select_grouped_def_nodes(node).each do |grouped_def_node|
+              insert_inline_modifier(corrector, grouped_def_node, node.method_name)
+            end
+          end
+        end
+
         def allow_modifiers_on_symbols?(node)
           cop_config['AllowModifiersOnSymbols'] && access_modifier_with_symbol?(node)
         end
@@ -130,6 +158,74 @@ module RuboCop
             format(INLINE_STYLE_MESSAGE, access_modifier: access_modifier)
           end
         end
+
+        def find_corresponding_def_node(node)
+          if access_modifier_with_symbol?(node)
+            method_name = node.arguments.first.value
+            node.parent.each_child_node(:def).find do |child|
+              child.method?(method_name)
+            end
+          else
+            node.arguments.first
+          end
+        end
+
+        def find_argument_less_modifier_node(node)
+          node.parent.each_child_node(:send).find do |child|
+            child.method?(node.method_name) && child.arguments.empty?
+          end
+        end
+
+        def select_grouped_def_nodes(node)
+          node.right_siblings.take_while do |sibling|
+            !(sibling.send_type? && sibling.bare_access_modifier_declaration?)
+          end.select(&:def_type?)
+        end
+
+        def insert_def(corrector, node, source)
+          source = [*processed_source.ast_with_comments[node].map(&:text), source].join("\n")
+          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}")
+          else
+            corrector.insert_before(
+              node.each_ancestor(:block, :class, :module).first.location.end,
+              "#{node.method_name}\n\n#{source}\n"
+            )
+          end
+        end
+
+        def insert_inline_modifier(corrector, node, modifier_name)
+          corrector.insert_before(node, "#{modifier_name} ")
+        end
+
+        def remove_node(corrector, node)
+          corrector.remove(
+            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 do |element|
+            element.location.expression
+          end
+          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/style/accessor_grouping.rb

@@ -135,12 +135,16 @@ module RuboCop
         end
 
         def separate_accessors(node)
-          node.arguments.map do |arg|
-            if arg == node.arguments.first
+          node.arguments.flat_map do |arg|
+            lines = [
+              *processed_source.ast_with_comments[arg].map(&:text),
               "#{node.method_name} #{arg.source}"
+            ]
+            if arg == node.arguments.first
+              lines
             else
               indent = ' ' * node.loc.column
-              "#{indent}#{node.method_name} #{arg.source}"
+              lines.map { |line| "#{indent}#{line}" }
             end
           end.join("\n")
         end

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

@@ -157,7 +157,7 @@ module RuboCop
       #     process(something)
       #   }
       #
-      # @example AllowedPatterns: [/map/]
+      # @example AllowedPatterns: ['map']
       #
       #   # good
       #   things.map { |thing|

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

@@ -7,6 +7,9 @@ module RuboCop
       #
       # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
       # the case equality operator is a constant.
+
+      # If `AllowOnSelfClass` option is enabled, the cop will ignore violations when the receiver of
+      # the case equality operator is `self.class`. Note intermediate variables are not accepted.
       #
       # @example
       #   # bad
@@ -26,6 +29,14 @@ module RuboCop
       #   # good
       #   Array === something
       #
+      # @example AllowOnSelfClass: false (default)
+      #   # bad
+      #   self.class === something
+      #
+      # @example AllowOnSelfClass: true
+      #   # good
+      #   self.class === something
+      #
       class CaseEquality < Base
         extend AutoCorrector
 
@@ -33,7 +44,10 @@ module RuboCop
         RESTRICT_ON_SEND = %i[===].freeze
 
         # @!method case_equality?(node)
-        def_node_matcher :case_equality?, '(send $#const? :=== $_)'
+        def_node_matcher :case_equality?, '(send $#offending_receiver? :=== $_)'
+
+        # @!method self_class?(node)
+        def_node_matcher :self_class?, '(send (self) :class)'
 
         def on_send(node)
           case_equality?(node) do |lhs, rhs|
@@ -48,12 +62,11 @@ module RuboCop
 
         private
 
-        def const?(node)
-          if cop_config.fetch('AllowOnConstant', false)
-            !node&.const_type?
-          else
-            true
-          end
+        def offending_receiver?(node)
+          return false if node&.const_type? && cop_config.fetch('AllowOnConstant', false)
+          return false if self_class?(node) && cop_config.fetch('AllowOnSelfClass', false)
+
+          true
         end
 
         def replacement(lhs, rhs)
@@ -66,12 +79,29 @@ module RuboCop
             #
             # So here is noop.
           when :begin
-            child = lhs.children.first
-            "#{lhs.source}.include?(#{rhs.source})" if child&.range_type?
+            begin_replacement(lhs, rhs)
           when :const
-            "#{rhs.source}.is_a?(#{lhs.source})"
+            const_replacement(lhs, rhs)
+          when :send
+            send_replacement(lhs, rhs)
           end
         end
+
+        def begin_replacement(lhs, rhs)
+          return unless lhs.children.first&.range_type?
+
+          "#{lhs.source}.include?(#{rhs.source})"
+        end
+
+        def const_replacement(lhs, rhs)
+          "#{rhs.source}.is_a?(#{lhs.source})"
+        end
+
+        def send_replacement(lhs, rhs)
+          return unless self_class?(lhs)
+
+          "#{rhs.source}.is_a?(#{lhs.source})"
+        end
       end
     end
   end

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

@@ -48,7 +48,7 @@ module RuboCop
       #   var.class.eql?(Date)
       #   var.class.name == 'Date'
       #
-      # @example AllowedPatterns: [`/eq/`]
+      # @example AllowedPatterns: ['eq']
       #   # good
       #   var.instance_of?(Date)
       #   var.class.equal?(Date)

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

@@ -36,8 +36,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-
         RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+        TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
         # @!method reject_method_with_block_pass?(node)
         def_node_matcher :reject_method_with_block_pass?, <<~PATTERN
@@ -69,6 +69,7 @@ module RuboCop
 
         def on_send(node)
           return unless (range = offense_range(node))
+          return if target_ruby_version <= 3.0 && to_enum_method?(node)
 
           good = good_method_name(node)
           message = format(MSG, good: good, bad: range.source)
@@ -94,6 +95,10 @@ module RuboCop
           end
         end
 
+        def to_enum_method?(node)
+          TO_ENUM_METHODS.include?(node.children.first.method_name)
+        end
+
         def good_method_name(node)
           if node.bang_method?
             'compact!'

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

@@ -28,14 +28,14 @@ module RuboCop
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
         def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
-          return unless offending_each_range(node)
+          return unless offending?(node)
 
           send_node = node.send_node
 
           range = send_node.receiver.source_range.join(send_node.loc.selector)
 
           add_offense(range) do |corrector|
-            range_type, min, max = offending_each_range(node)
+            range_type, min, max = each_range(node)
 
             max += 1 if range_type == :irange
 
@@ -45,9 +45,44 @@ module RuboCop
 
         private
 
-        # @!method offending_each_range(node)
-        def_node_matcher :offending_each_range, <<~PATTERN
-          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
+        def offending?(node)
+          each_range_with_zero_origin?(node) || each_range_without_block_argument?(node)
+        end
+
+        # @!method each_range(node)
+        def_node_matcher :each_range, <<~PATTERN
+          (block
+            (send
+              (begin
+                (${irange erange}
+                  (int $_) (int $_)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_with_zero_origin?(node)
+        def_node_matcher :each_range_with_zero_origin?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int 0) (int _)))
+              :each)
+            (args ...)
+            ...)
+        PATTERN
+
+        # @!method each_range_without_block_argument?(node)
+        def_node_matcher :each_range_without_block_argument?, <<~PATTERN
+          (block
+            (send
+              (begin
+                ({irange erange}
+                  (int _) (int _)))
+              :each)
+            (args)
+            ...)
         PATTERN
       end
     end

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

@@ -52,7 +52,7 @@ module RuboCop
         MSG_EXPANDED = 'Put the `end` of empty method definitions on the next line.'
 
         def on_def(node)
-          return if node.body || comment_lines?(node)
+          return if node.body || processed_source.contains_comment?(node.source_range)
           return if correct_style?(node)
 
           add_offense(node) do |corrector|

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

@@ -39,7 +39,7 @@ module RuboCop
       #
       # @example EnforcedStyle: disallow
       #   # bad
-      #   def my_method; x end
+      #   def my_method() = x
       #
       #   # bad
       #   def my_method() = x.foo

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

@@ -50,6 +50,10 @@ module RuboCop
           (block $_ (args $...) (yield $...))
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Lint::UnusedMethodArgument]
+        end
+
         def initialize(config = nil, options = nil)
           super
           @def_nodes = Set.new

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

@@ -77,7 +77,7 @@ module RuboCop
       #   # bad
       #   redirect('foo/%{bar_id}')
       #
-      # @example AllowedPatterns: [/redirect/]
+      # @example AllowedPatterns: ['redirect']
       #
       #   # good
       #   redirect('foo/%{bar_id}')

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

@@ -28,7 +28,7 @@ module RuboCop
       # * always - forces use of the 3.1 syntax (e.g. {foo:})
       # * never - forces use of explicit hash literal value
       # * either - accepts both shorthand and explicit use of hash literal value
-      # * consistent - like "always", but will avoid mixing styles in a single hash
+      # * consistent - like "either", but will avoid mixing styles in a single hash
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -20,8 +20,8 @@ module RuboCop
             return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
-            return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
@@ -97,7 +97,8 @@ module RuboCop
               call_in_optional_arguments?(node) ||
               call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
-              allowed_chained_call_with_parentheses?(node)
+              allowed_chained_call_with_parentheses?(node) ||
+              assignment_in_condition?(node)
           end
 
           def call_in_literals?(node)
@@ -202,6 +203,16 @@ module RuboCop
           def inside_string_interpolation?(node)
             node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
           end
+
+          def assignment_in_condition?(node)
+            parent = node.parent
+            return false unless parent
+
+            grandparent = parent.parent
+            return false unless grandparent
+
+            parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
+          end
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end

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

@@ -49,7 +49,8 @@ module RuboCop
         def on_if(node)
           return unless if_else?(node)
 
-          condition = node.condition
+          condition = unwrap_begin_nodes(node.condition)
+
           return if double_negation?(condition) || !negated_condition?(condition)
 
           type = node.ternary? ? 'ternary' : 'if-else'
@@ -71,6 +72,11 @@ module RuboCop
           !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
         end
 
+        def unwrap_begin_nodes(node)
+          node = node.children.first while node.begin_type? || node.kwbegin_type?
+          node
+        end
+
         def negated_condition?(node)
           node.send_type? &&
             (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))

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

@@ -66,7 +66,7 @@ module RuboCop
       #   foo.negative?
       #   bar.baz.positive?
       #
-      # @example AllowedPatterns: [/zero/] with EnforcedStyle: predicate
+      # @example AllowedPatterns: ['zero'] with EnforcedStyle: predicate
       #   # good
       #   # bad
       #   foo.zero?

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant dot before operator method call.
+      # The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
+      # `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo.+ bar
+      #   foo.& bar
+      #
+      #   # good
+      #   foo + bar
+      #   foo & bar
+      #
+      class OperatorMethodCall < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant dot detected.'
+        RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
+
+        def on_send(node)
+          return unless (dot = node.loc.dot)
+
+          _lhs, _op, rhs = *node
+          return if rhs.children.first
+
+          add_offense(dot) do |corrector|
+            corrector.replace(dot, ' ')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -83,10 +83,31 @@ module RuboCop
           end
         end
 
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to_node_with_constant_prefix(node)
+          expression = preferred_expression_to(node)
+          return unless expression
+
+          "#{constant_prefix(node)}#{expression}"
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def constant_prefix(node)
+          if node.each_ancestor(:class, :module).any?
+            '::'
+          else
+            ''
+          end
+        end
+
         # @private
         # @param [RuboCop::AST::Node] node
         def on_back_ref_or_gvar_or_nth_ref(node)
-          preferred_expression = preferred_expression_to(node)
+          preferred_expression = preferred_expression_to_node_with_constant_prefix(node)
           return unless preferred_expression
 
           add_offense(

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

@@ -75,6 +75,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.body&.kwbegin_type?
+          return if node.endless? && !node.body.children.one?
 
           register_offense(node.body)
         end

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

@@ -145,11 +145,14 @@ module RuboCop
 
           return false unless if_branch && else_branch
 
-          if_branch.send_type? && if_branch.arguments.count == 1 &&
-            else_branch.send_type? && else_branch.arguments.count == 1 &&
+          single_argument_method?(if_branch) && single_argument_method?(else_branch) &&
             same_method?(if_branch, else_branch)
         end
 
+        def single_argument_method?(node)
+          node.send_type? && !node.method?(:[]) && node.arguments.one?
+        end
+
         def same_method?(if_branch, else_branch)
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         end

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

@@ -140,7 +140,9 @@ module RuboCop
         end
 
         def allow_comments?(node)
-          cop_config['AllowComments'] && contains_comments?(node)
+          return false unless cop_config['AllowComments']
+
+          contains_comments?(node) && !comments_contain_disables?(node, name)
         end
 
         def same_args?(super_node, args)

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

@@ -29,6 +29,9 @@ module RuboCop
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
 
+        # @!method allowed_pin_operator?(node)
+        def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
+
         # @!method arg_in_call_with_block?(node)
         def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
 
@@ -44,6 +47,7 @@ module RuboCop
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
 

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

@@ -74,7 +74,7 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) ||
+            backslash_b?(class_elem) || backslash_zero?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
@@ -104,6 +104,13 @@ module RuboCop
           elem == '\b'
         end
 
+        def backslash_zero?(elem)
+          # See https://github.com/rubocop/rubocop/issues/11067 for details - in short "\0" != "0" -
+          # the former means an Unicode code point `"\u0000"`, the latter a number character `"0"`.
+          # Similarly "\032" means "\u001A". Other numbers starting with "\0" can also be mentioned.
+          elem == '\0'
+        end
+
         def requires_escape_outside_char_class?(elem)
           REQUIRES_ESCAPE_OUTSIDE_CHAR_CLASS_CHARS.include?(elem)
         end