rubocop 1.60.0 → 1.61.0

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -34,18 +34,14 @@ module RuboCop
       end
 
       def offending_range
+        begin_range = block_node.source_range.begin
+
         if block_node.arguments?
-          replacement_range(argument_node.source_range.end_pos)
+          begin_range.join(argument_node.source_range.end)
         else
-          replacement_range(block_node.loc.begin.end_pos)
+          begin_range.join(block_node.loc.begin.end)
         end
       end
-
-      def replacement_range(end_pos)
-        Parser::Source::Range.new(block_node.source_range.source_buffer,
-                                  block_node.source_range.begin_pos,
-                                  end_pos)
-      end
     end
   end
 end

data/lib/rubocop/cop/correctors/for_to_each_corrector.rb

@@ -15,6 +15,8 @@ module RuboCop
       end
 
       def call(corrector)
+        offending_range = for_node.source_range.begin.join(end_range)
+
         corrector.replace(offending_range, correction)
       end
 
@@ -40,11 +42,11 @@ module RuboCop
         collection_node.range_type? || collection_node.or_type? || collection_node.and_type?
       end
 
-      def end_position
+      def end_range
         if for_node.do?
-          keyword_begin.end_pos
+          keyword_begin.end
         else
-          collection_end.end_pos
+          collection_end.end
         end
       end
 
@@ -59,16 +61,6 @@ module RuboCop
           collection_node.source_range
         end
       end
-
-      def offending_range
-        replacement_range(end_position)
-      end
-
-      def replacement_range(end_pos)
-        Parser::Source::Range.new(for_node.source_range.source_buffer,
-                                  for_node.source_range.begin_pos,
-                                  end_pos)
-      end
     end
   end
 end

data/lib/rubocop/cop/gemspec/required_ruby_version.rb

@@ -110,6 +110,8 @@ module RuboCop
             end
           end
 
+          return unless required_ruby_version
+
           required_ruby_version.str_content.scan(/\d/).first(2).join('.')
         end
 

data/lib/rubocop/cop/internal_affairs/example_description.rb

@@ -63,10 +63,10 @@ module RuboCop
           expect_correction: EXPECT_CORRECTION_DESCRIPTION_MAPPING
         }.freeze
 
-        # @!method offense_example?(node)
-        def_node_matcher :offense_example?, <<~PATTERN
+        # @!method offense_example(node)
+        def_node_matcher :offense_example, <<~PATTERN
           (block
-            (send _ {:it :specify} $_description)
+            (send _ {:it :specify} $...)
             _args
             `(send nil? %RESTRICT_ON_SEND ...)
           )
@@ -74,7 +74,7 @@ module RuboCop
 
         def on_send(node)
           parent = node.each_ancestor(:block).first
-          return unless parent && (current_description = offense_example?(parent))
+          return unless parent && (current_description = offense_example(parent)&.first)
 
           method_name = node.method_name
           message = format(MSG, method_name: method_name)

data/lib/rubocop/cop/internal_affairs/method_name_end_with.rb

@@ -30,6 +30,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `%<method_name>s` instead of `%<method_suffix>s`.'
+        RESTRICT_ON_SEND = %i[end_with?].freeze
         SUGGEST_METHOD_FOR_SUFFIX = {
           '=' => 'assignment_method?',
           '!' => 'bang_method?',
@@ -51,14 +52,15 @@ module RuboCop
 
         def on_send(node)
           method_name_end_with?(node) do |method_name_node, end_with_arg|
+            next unless method_name_node.receiver
+
+            preferred_method = SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value]
             range = range(method_name_node, node)
-            message = format(
-              MSG,
-              method_name: SUGGEST_METHOD_FOR_SUFFIX[end_with_arg.value],
-              method_suffix: range.source
-            )
+            message = format(MSG, method_name: preferred_method, method_suffix: range.source)
 
-            add_offense(range, message: message)
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, preferred_method)
+            end
           end
         end
         alias on_csend on_send

data/lib/rubocop/cop/internal_affairs/redundant_expect_offense_arguments.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for redundant arguments of `RuboCop::RSpec::ExpectOffense`'s methods.
+      #
+      # @example
+      #
+      #   # bad
+      #   expect_no_offenses('code', keyword: keyword)
+      #
+      #   # good
+      #   expect_no_offenses('code')
+      #
+      class RedundantExpectOffenseArguments < Base
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant arguments.'
+        RESTRICT_ON_SEND = %i[expect_no_offenses].freeze
+
+        def on_send(node)
+          return if node.arguments.one? || !node.arguments[1]&.hash_type?
+
+          range = node.first_argument.source_range.end.join(node.last_argument.source_range.end)
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs.rb

@@ -20,6 +20,7 @@ require_relative 'internal_affairs/offense_location_keyword'
 require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
+require_relative 'internal_affairs/redundant_expect_offense_arguments'
 require_relative 'internal_affairs/redundant_let_rubocop_config_new'
 require_relative 'internal_affairs/redundant_location_argument'
 require_relative 'internal_affairs/redundant_message_argument'

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -20,7 +20,9 @@ module RuboCop
       # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
       # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
-      # to align with the start of the line. These style can be configured by each cop.
+      # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default.
+      # These style can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: keyword (default)
       #   # bad

data/lib/rubocop/cop/layout/redundant_line_break.rb

@@ -85,7 +85,13 @@ module RuboCop
 
         def offense?(node)
           node.multiline? && !too_long?(node) && suitable_as_single_line?(node) &&
-            !configured_to_not_be_inspected?(node)
+            !index_access_call_chained?(node) && !configured_to_not_be_inspected?(node)
+        end
+
+        def index_access_call_chained?(node)
+          return false unless node.send_type? && node.method?(:[])
+
+          node.children.first.send_type? && node.children.first.method?(:[])
         end
 
         def configured_to_not_be_inspected?(node)

data/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -81,19 +81,28 @@ module RuboCop
         private
 
         def check_empty(left_brace, space_plus_brace, used_style)
-          return if style_for_empty_braces == used_style
-
-          config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          if style_for_empty_braces == used_style
+            handle_different_styles_for_empty_braces(used_style)
+            return
+          elsif !config_to_allow_offenses.key?('Enabled')
+            config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
+          end
 
           if style_for_empty_braces == :space
-            add_offense(left_brace, message: MISSING_MSG) do |corrector|
-              autocorrect(corrector, left_brace)
-            end
+            range = left_brace
+            msg = MISSING_MSG
           else
-            space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
-            add_offense(space, message: DETECTED_MSG) do |corrector|
-              autocorrect(corrector, space)
-            end
+            range = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
+            msg = DETECTED_MSG
+          end
+          add_offense(range, message: msg) { |corrector| autocorrect(corrector, range) }
+        end
+
+        def handle_different_styles_for_empty_braces(used_style)
+          if config_to_allow_offenses['EnforcedStyleForEmptyBraces'] &&
+             config_to_allow_offenses['EnforcedStyleForEmptyBraces'].to_sym != used_style
+            config_to_allow_offenses.clear
+            config_to_allow_offenses['Enabled'] = false
           end
         end
 

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

@@ -104,7 +104,7 @@ module RuboCop
         def correct_other_branches(corrector, node)
           return unless require_other_branches_correction?(node)
 
-          if node.else_branch&.if_type?
+          if node.else_branch&.if_type? && !node.else_branch.modifier_form?
             # Replace an orphaned `elsif` with `if`
             corrector.replace(node.else_branch.loc.keyword, 'if')
           else

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

@@ -5,7 +5,8 @@ module RuboCop
     module Lint
       # Checks for redundant safe navigation calls.
       # Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
-      # and an offense is not detected when the receiver is a snake case constant.
+      # and an offense is not detected when the receiver is a constant. The detection also applies
+      # to literal receivers, except for `nil`.
       #
       # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
       # and `equal?` methods are checked by default.
@@ -76,10 +77,9 @@ module RuboCop
       #
       class RedundantSafeNavigation < Base
         include AllowedMethods
-        include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Redundant safe navigation detected.'
+        MSG = 'Redundant safe navigation detected, use `.` instead.'
         MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
 
         NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
@@ -105,24 +105,23 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize
         def on_csend(node)
-          unless node.receiver.const_type? && !node.receiver.source.match?(SNAKE_CASE)
+          unless assume_receiver_instance_exists?(node.receiver)
             return unless check?(node) && allowed_method?(node.method_name)
             return if respond_to_nil_specific_method?(node)
           end
 
-          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
-          add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
+          range = node.loc.dot
+          add_offense(range) { |corrector| corrector.replace(range, '.') }
         end
 
         def on_or(node)
           conversion_with_default?(node) do |send_node|
-            range = range_between(send_node.loc.dot.begin_pos, node.source_range.end_pos)
+            range = send_node.loc.dot.begin.join(node.source_range.end)
 
             add_offense(range, message: MSG_LITERAL) do |corrector|
               corrector.replace(send_node.loc.dot, '.')
 
-              range_with_default = range_between(node.lhs.source_range.end.begin_pos,
-                                                 node.source_range.end.end_pos)
+              range_with_default = node.lhs.source_range.end.begin.join(node.source_range.end)
               corrector.remove(range_with_default)
             end
           end
@@ -131,6 +130,12 @@ module RuboCop
 
         private
 
+        def assume_receiver_instance_exists?(receiver)
+          return true if receiver.const_type? && !receiver.source.match?(SNAKE_CASE)
+
+          receiver.literal? && !receiver.nil_type?
+        end
+
         def check?(node)
           parent = node.parent
           return false unless parent

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

@@ -59,9 +59,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            node.loc.keyword.end_pos,
-                                            rescued.source_range.end_pos)
+          range = node.loc.keyword.end.join(rescued.source_range.end)
 
           corrector.replace(range, correction(*rescued))
         end

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

@@ -46,14 +46,14 @@ module RuboCop
           message = format_message_from(processed_source)
 
           add_offense(comment, message: message) do
-            autocorrect(comment) if autocorrect_requested?
+            autocorrect if autocorrect_requested?
           end
         end
 
         private
 
-        def autocorrect(comment)
-          FileUtils.chmod('+x', comment.source_range.source_buffer.name)
+        def autocorrect
+          FileUtils.chmod('+x', processed_source.file_path)
         end
 
         def executable?(processed_source)

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

@@ -17,7 +17,7 @@ module RuboCop
         private
 
         def add_offense_from_diagnostic(diagnostic, ruby_version)
-          message = if lsp_mode?
+          message = if LSP.enabled?
                       diagnostic.message
                     else
                       "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \

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

@@ -100,7 +100,12 @@ module RuboCop
           expressions = *node
           expressions.pop unless in_void_context?(node)
           expressions.each do |expr|
-            check_void_op(expr)
+            check_void_op(expr) do
+              block_node = node.each_ancestor(:block).first
+
+              block_node&.method?(:each)
+            end
+
             check_expression(expr)
           end
         end

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

@@ -99,7 +99,7 @@ module RuboCop
           !(method_name.start_with?(prefix) && # cheap check to avoid allocating Regexp
               method_name.match?(/^#{prefix}[^0-9]/)) ||
             method_name == expected_name(method_name, prefix) ||
-            method_name.end_with?('=') || # rubocop:todo InternalAffairs/MethodNameEndWith
+            method_name.end_with?('=') ||
             allowed_method?(method_name)
         end
 
@@ -109,7 +109,7 @@ module RuboCop
                      else
                        method_name.dup
                      end
-          new_name << '?' unless method_name.end_with?('?') # rubocop:todo InternalAffairs/MethodNameEndWith
+          new_name << '?' unless method_name.end_with?('?')
           new_name
         end
 

data/lib/rubocop/cop/registry.rb

@@ -240,12 +240,12 @@ module RuboCop
         self
       end
 
-      def select(...)
-        cops.select(...)
+      def select(&block)
+        cops.select(&block)
       end
 
-      def each(...)
-        cops.each(...)
+      def each(&block)
+        cops.each(&block)
       end
 
       # @param [String] cop_name
@@ -300,7 +300,7 @@ module RuboCop
         unless given_badge.match?(real_badge)
           path = PathUtil.smart_path(source_path)
           warn "#{path}: #{given_badge} has the wrong namespace - " \
-               "should be #{real_badge.department}"
+               "replace it with #{given_badge.with_department(real_badge.department)}"
         end
 
         real_badge.to_s

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

@@ -8,6 +8,12 @@ module RuboCop
       # This cop identifies places where `do_something(*args, &block)`
       # can be replaced by `do_something(...)`.
       #
+      # In Ruby 3.1, anonymous block forwarding has been added.
+      #
+      # This cop identifies places where `do_something(&block)` can be replaced
+      # by `do_something(&)`; if desired, this functionality can be disabled
+      # by setting `UseAnonymousForwarding: false`.
+      #
       # In Ruby 3.2, anonymous args/kwargs forwarding has been added.
       #
       # This cop also identifies places where `use_args(*args)`/`use_kwargs(**kwargs)` can be
@@ -41,22 +47,25 @@ module RuboCop
       #
       # @example UseAnonymousForwarding: true (default, only relevant for Ruby >= 3.2)
       #   # bad
-      #   def foo(*args, **kwargs)
+      #   def foo(*args, **kwargs, &block)
       #     args_only(*args)
       #     kwargs_only(**kwargs)
+      #     block_only(&block)
       #   end
       #
       #   # good
-      #   def foo(*, **)
+      #   def foo(*, **, &)
       #     args_only(*)
       #     kwargs_only(**)
+      #     block_only(&)
       #   end
       #
       # @example UseAnonymousForwarding: false (only relevant for Ruby >= 3.2)
       #   # good
-      #   def foo(*args, **kwargs)
+      #   def foo(*args, **kwargs, &block)
       #     args_only(*args)
       #     kwargs_only(**kwargs)
+      #     block_only(&block)
       #   end
       #
       # @example AllowOnlyRestArgument: true (default, only relevant for Ruby < 3.2)
@@ -104,7 +113,7 @@ module RuboCop
       #   end
       #
       # @example RedundantBlockArgumentNames: ['blk', 'block', 'proc'] (default)
-      #   # bad
+      #   # bad - But it is good with `EnforcedStyle: explicit` set for `Naming/BlockForwarding`.
       #   def foo(&block)
       #     bar(&block)
       #   end
@@ -126,6 +135,7 @@ module RuboCop
         FORWARDING_MSG = 'Use shorthand syntax `...` for arguments forwarding.'
         ARGS_MSG = 'Use anonymous positional arguments forwarding (`*`).'
         KWARGS_MSG = 'Use anonymous keyword arguments forwarding (`**`).'
+        BLOCK_MSG = 'Use anonymous block arguments forwarding (`&`).'
 
         def self.autocorrect_incompatible_with
           [Naming::BlockForwarding]
@@ -171,21 +181,40 @@ module RuboCop
           send_classifications.all? { |_, c, _, _| c == :all }
         end
 
+        # rubocop:disable Metrics/MethodLength
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
-          send_classifications.each do |send_node, _c, forward_rest, _forward_kwrest|
-            register_forward_all_offense(send_node, send_node, forward_rest)
+          _rest_arg, _kwrest_arg, block_arg = *forwardable_args
+          registered_block_arg_offense = false
+
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
+            if !forward_rest && !forward_kwrest
+              # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
+              # in Ruby 3.3.0.
+              if outside_block?(forward_block_arg)
+                register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
+                register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
+              end
+              registered_block_arg_offense = true
+              break
+            else
+              register_forward_all_offense(send_node, send_node, forward_rest)
+            end
           end
 
+          return if registered_block_arg_offense
+
           rest_arg, _kwrest_arg, _block_arg = *forwardable_args
           register_forward_all_offense(node, node.arguments, rest_arg)
         end
+        # rubocop:enable Metrics/MethodLength
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
 
-          rest_arg, kwrest_arg, _block_arg = *forwardable_args
+          rest_arg, kwrest_arg, block_arg = *forwardable_args
 
-          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest|
+          send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
             if outside_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
@@ -195,8 +224,16 @@ module RuboCop
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
+
+            # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
+            # in Ruby 3.3.0.
+            if outside_block?(forward_block_arg)
+              register_forward_block_arg_offense(!forward_rest, def_node.arguments, block_arg)
+              register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
+            end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def non_splat_or_block_pass_lvar_references(body)
           body.each_descendant(:lvar, :lvasgn).filter_map do |lvar|
@@ -225,10 +262,7 @@ module RuboCop
 
         def classification_and_forwards(def_node, send_node, referenced_lvars, forwardable_args)
           classifier = SendNodeClassifier.new(
-            def_node,
-            send_node,
-            referenced_lvars,
-            forwardable_args,
+            def_node, send_node, referenced_lvars, forwardable_args,
             target_ruby_version: target_ruby_version,
             allow_only_rest_arguments: allow_only_rest_arguments?
           )
@@ -237,7 +271,12 @@ module RuboCop
 
           return unless classification
 
-          [classification, classifier.forwarded_rest_arg, classifier.forwarded_kwrest_arg]
+          [
+            classification,
+            classifier.forwarded_rest_arg,
+            classifier.forwarded_kwrest_arg,
+            classifier.forwarded_block_arg
+          ]
         end
 
         def redundant_named_arg(arg, config_name, keyword)
@@ -272,6 +311,16 @@ module RuboCop
           end
         end
 
+        def register_forward_block_arg_offense(add_parens, def_arguments_or_send, block_arg)
+          return if target_ruby_version <= 3.0 || block_arg.source == '&' || explicit_block_name?
+
+          add_offense(block_arg, message: BLOCK_MSG) do |corrector|
+            add_parens_if_missing(def_arguments_or_send, corrector) if add_parens
+
+            corrector.replace(block_arg, '&')
+          end
+        end
+
         def register_forward_all_offense(def_or_send, send_or_arguments, rest_or_splat)
           arg_range = arguments_range(def_or_send, rest_or_splat)
 
@@ -441,6 +490,13 @@ module RuboCop
               (@kwrest_arg_name && !forwarded_kwrest_arg)
           end
         end
+
+        def explicit_block_name?
+          block_forwarding_config = config.for_cop('Naming/BlockForwarding')
+          return false unless block_forwarding_config['Enabled']
+
+          block_forwarding_config['EnforcedStyle'] == 'explicit'
+        end
       end
     end
   end

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

@@ -230,7 +230,7 @@ module RuboCop
 
         def branch_conditions(node)
           conditions = []
-          while node&.if_type?
+          while node&.if_type? && !node.ternary?
             conditions << node.condition
             node = node.else_branch
           end

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

@@ -23,6 +23,8 @@ module RuboCop
       #   array.reject { |e| e.nil? }
       #   array.delete_if { |e| e.nil? }
       #   array.select { |e| !e.nil? }
+      #   array.grep_v(nil)
+      #   array.grep_v(NilClass)
       #
       #   # good
       #   array.compact
@@ -46,7 +48,7 @@ module RuboCop
         extend TargetRubyVersion
 
         MSG = 'Use `%<good>s` instead of `%<bad>s`.'
-        RESTRICT_ON_SEND = %i[reject delete_if reject! select select!].freeze
+        RESTRICT_ON_SEND = %i[reject delete_if reject! select select! grep_v].freeze
         TO_ENUM_METHODS = %i[to_enum lazy].freeze
 
         minimum_target_ruby_version 2.4
@@ -79,6 +81,11 @@ module RuboCop
                 $(lvar _) :nil?) :!))
         PATTERN
 
+        # @!method grep_v_with_nil?(node)
+        def_node_matcher :grep_v_with_nil?, <<~PATTERN
+          (send _ :grep_v {(nil) (const {nil? cbase} :NilClass)})
+        PATTERN
+
         def on_send(node)
           return unless (range = offense_range(node))
           return if allowed_receiver?(node.receiver)
@@ -95,8 +102,9 @@ module RuboCop
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def offense_range(node)
-          if reject_method_with_block_pass?(node)
+          if reject_method_with_block_pass?(node) || grep_v_with_nil?(node)
             range(node, node)
           else
             block_node = node.parent
@@ -110,6 +118,7 @@ module RuboCop
             range(node, block_node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def to_enum_method?(node)
           return false unless node.receiver.send_type?