rubocop 1.84.0 → 1.84.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbf40b2db6dffc0c0f6685b18afbef40441dfc3650f0176a701ca9442748d12b
-  data.tar.gz: 4a40e7f7dbc92057286865804e49fa60b33391cd1947d87447fdaa18a1ad6dd2
+  metadata.gz: 358bce5232f7b6e4e490a3d173d09cb4d3df8fc9e92355b550d0047e10e0f462
+  data.tar.gz: 8e65d98bd3478db7eee250dd05ffc6fd4f4d17d144207950fc12f5e83f7995f6
 SHA512:
-  metadata.gz: 0da21b5bc8b4db1ce03eefd577ee4e680354fb4b9bc8c4a1626b74dfe4d8ca4c31f4fcd629a635596db74d8d270686d3b353c3378ccd4d6d7b154129ea4af038
-  data.tar.gz: 1b470746489d85337a2ce6f9304d69b875c079a72f383fd8bf2f5154535cac98618341022fc5a5bf1d1fdc5ebe02f6be69d82f64d97c04d250215d41bb7f598b
+  metadata.gz: 4b6cf48e7582909807829dd43e7fd379a9e4ec46cd387659a16321f4fd3ee7a321ac16859ce86870d41fae2602abde14197e1bb91094abb8bf9dd809dc6e648e
+  data.tar.gz: c619779f7ac9d8563aadc5f6675333f22d7c8d2300d6ac1c996260d442210f6b2b809f24e7fa1479b6b908a0ca16bc8f61bc23200f3e2f302e03369bce6dafac

data/config/default.yml

@@ -3113,6 +3113,7 @@ Naming/PredicateMethod:
   AllowBangMethods: false
   # Methods that are known to not return a boolean value, despite ending in `?`.
   WaywardPredicates:
+    - infinite?
     - nonzero?
 
 Naming/PredicatePrefix:
@@ -3980,7 +3981,7 @@ Style/EmptyCaseCondition:
 Style/EmptyClassDefinition:
   Description: 'Enforces consistent style for empty class definitions.'
   Enabled: pending
-  VersionAdded: '1.83'
+  VersionAdded: '1.84'
   EnforcedStyle: class_definition
   SupportedStyles:
     - class_definition
@@ -4341,7 +4342,7 @@ Style/HashLookupMethod:
   Description: 'Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup.'
   Enabled: false
   Safe: false
-  VersionAdded: '1.83'
+  VersionAdded: '1.84'
   EnforcedStyle: brackets
   SupportedStyles:
     - brackets
@@ -4444,6 +4445,7 @@ Style/IfWithBooleanLiteralBranches:
   VersionAdded: '1.9'
   SafeAutoCorrect: false
   AllowedMethods:
+    - infinite?
     - nonzero?
 
 Style/IfWithSemicolon:
@@ -4912,7 +4914,7 @@ Style/NegativeArrayIndex:
     Also handles range patterns with length calculations. Recognizes preserving methods
     and their combinations, allowing safe replacement when the receiver matches.
   Enabled: pending
-  VersionAdded: '1.83'
+  VersionAdded: '1.84'
 
 Style/NestedFileDirname:
   Description: 'Checks for nested `File.dirname`.'
@@ -5317,6 +5319,7 @@ Style/RedundantCondition:
   VersionAdded: '0.76'
   VersionChanged: '1.73'
   AllowedMethods:
+    - infinite?
     - nonzero?
 
 Style/RedundantConditional:
@@ -5569,7 +5572,7 @@ Style/ReverseFind:
   Description: 'Use `array.rfind` instead of `array.reverse.find`.'
   Enabled: pending
   Safe: false
-  VersionAdded: '1.83'
+  VersionAdded: '1.84'
 
 Style/SafeNavigation:
   Description: >-

data/lib/rubocop/comment_config.rb

@@ -103,8 +103,9 @@ module RuboCop
 
       each_directive do |directive|
         if directive.push?
-          @stack.push(snapshot_analyses(analyses))
-          apply_push_args(analyses, directive)
+          resolved = resolve_push_cops(directive)
+          @stack.push(snapshot_cops(analyses, resolved.values.flatten))
+          apply_push(analyses, resolved, directive.line_number)
         elsif directive.pop?
           pop_state(analyses, directive.line_number) if @stack.any?
         else
@@ -121,48 +122,46 @@ module RuboCop
       end
     end
 
-    def snapshot_analyses(analyses)
-      analyses.transform_values { |a| CopAnalysis.new(a.line_ranges.dup, a.start_line_number) }
+    def snapshot_cops(analyses, cop_names)
+      cop_names.to_h { |name| [name, analyses[name].dup] }
     end
 
-    def pop_state(analyses, pop_line)
-      analyses.each do |cop_name, analysis|
-        next unless analysis.start_line_number
-
-        analyses[cop_name] = CopAnalysis.new(
-          analysis.line_ranges + [analysis.start_line_number...pop_line], nil
-        )
+    def resolve_push_cops(directive)
+      directive.push_args.transform_values do |names|
+        names.flat_map { |name| expand_cop_name(name) }
       end
+    end
 
-      @stack.pop.each do |cop_name, saved_analysis|
-        current = analyses[cop_name]
-        new_start = saved_analysis.start_line_number ? pop_line : nil
-        analyses[cop_name] = CopAnalysis.new(current.line_ranges, new_start)
-      end
+    def expand_cop_name(name)
+      registry = Cop::Registry.global
+      cops = registry.department?(name) ? registry.names_for_department(name) : [name]
+      cops.map { |c| qualified_cop_name(c) }
     end
 
-    def apply_push_args(analyses, directive)
-      directive.push_args.each do |operation, cop_names|
-        cop_names.each do |cop_name|
-          apply_cop_operation(analyses, operation, qualified_cop_name(cop_name),
-                              directive.line_number)
-        end
+    def apply_push(analyses, resolved_cops, line)
+      resolved_cops.each do |op, cops|
+        cops.each { |cop| apply_cop_op(analyses, op, cop, line) }
       end
     end
 
-    def apply_cop_operation(analyses, operation, cop_name, line)
-      analysis = analyses[cop_name]
-      start_line = analysis.start_line_number
-
-      case operation
-      when '+' # Enable cop
-        return unless start_line
-
-        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
-      when '-' # Disable cop
-        return if start_line
+    def apply_cop_op(analyses, operation, cop, line)
+      analysis = analyses[cop]
+      if operation == '-' && !analysis.start_line_number
+        analyses[cop] = CopAnalysis.new(analysis.line_ranges, line)
+      elsif operation == '+' && analysis.start_line_number
+        analyses[cop] =
+          CopAnalysis.new(analysis.line_ranges + [analysis.start_line_number..line], nil)
+      end
+    end
 
-        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges, line)
+    def pop_state(analyses, line)
+      saved = @stack.pop
+      saved.each do |cop, old|
+        cur = analyses[cop]
+        new_range = cur.start_line_number ? [cur.start_line_number..(line - 1)] : []
+        ranges = cur.line_ranges + new_range
+        new_start = old.start_line_number ? line : nil
+        analyses[cop] = CopAnalysis.new(ranges, new_start)
       end
     end
 

data/lib/rubocop/config_loader.rb

@@ -151,31 +151,22 @@ module RuboCop
       # When testing a plugin using `rubocop/rspec/support`, the plugin is loaded automatically,
       # so this API is usually not needed. It is intended to be used only when implementing tests
       # that do not use `rubocop/rspec/support`.
-      # rubocop:disable Metrics/MethodLength
       def inject_defaults!(config_yml_path)
         if Pathname(config_yml_path).directory?
-          # TODO: Since the warning noise is expected to be high until some time after the release,
-          # warnings will only be issued when `RUBYOPT=-w` is specified.
-          # To proceed step by step, the next step is to remove `$VERBOSE` and always issue warning.
-          # Eventually, `project_root` will no longer be accepted.
-          if $VERBOSE
-            warn Rainbow(<<~MESSAGE).yellow, uplevel: 1
-              Use config YAML file path instead of project root directory.
-              e.g., `path/to/config/default.yml`
-            MESSAGE
-          end
-          # NOTE: For compatibility.
-          project_root = config_yml_path
-          path = File.join(project_root, 'config', 'default.yml')
-          config = load_file(path)
-        else
-          hash = ConfigLoader.load_yaml_configuration(config_yml_path.to_s)
-          config = Config.new(hash, config_yml_path).tap(&:make_excludes_absolute)
+          warn Rainbow(<<~MESSAGE).yellow, uplevel: 1
+            Use config YAML file path instead of project root directory.
+            e.g., `path/to/config/default.yml`
+          MESSAGE
+          raise ArgumentError,
+                'Passing a project root directory to `inject_defaults!` is no longer supported.'
         end
 
+        path = config_yml_path.to_s
+        hash = ConfigLoader.load_yaml_configuration(path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
+
         @default_configuration = ConfigLoader.merge_with_default(config, path)
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Returns the path RuboCop inferred as the root of the project. No file
       # searches will go past this directory.

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

@@ -179,15 +179,24 @@ module RuboCop
 
           top_level_send = find_top_level_send(send_node)
           node_to_correct =
-            if top_level_send != send_node || should_correct_entire_method_call?(top_level_send)
-              top_level_send
-            else
-              node
-            end
+            should_correct_entire_chain?(send_node, top_level_send) ? top_level_send : node
 
           AlignmentCorrector.correct(corrector, processed_source, node_to_correct, column_delta)
         end
 
+        def should_correct_entire_chain?(send_node, top_level_send)
+          return false unless style == :special_for_inner_method_call_in_parentheses
+          return false unless inner_call?(top_level_send)
+
+          top_level_send != send_node || begins_its_line?(top_level_send.loc.end)
+        end
+
+        def inner_call?(top_level_send)
+          outer_call = top_level_send.parent
+
+          outer_call&.send_type? && outer_call.parenthesized?
+        end
+
         def find_top_level_send(send_node)
           top_level_send = send_node
           while top_level_send.parent&.send_type? &&
@@ -198,14 +207,6 @@ module RuboCop
           top_level_send
         end
 
-        def should_correct_entire_method_call?(send_node)
-          return false unless style == :special_for_inner_method_call_in_parentheses
-          return false unless special_inner_call_indentation?(send_node)
-
-          closing_paren = send_node.loc.end
-          closing_paren && begins_its_line?(closing_paren)
-        end
-
         def bare_operator?(node)
           node.operator_method? && !node.dot?
         end

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

@@ -424,7 +424,7 @@ module RuboCop
         end
 
         def contains_access_modifier?(body_node)
-          return false unless body_node.begin_type?
+          return false unless body_node&.begin_type?
 
           body_node.children.any? { |child| child.send_type? && child.bare_access_modifier? }
         end
@@ -473,10 +473,10 @@ module RuboCop
         end
 
         def block_body_indentation_base(node, end_loc)
-          if style != :relative_to_receiver || !dot_on_new_line?(node)
-            end_loc
-          else
+          if dot_on_new_line?(node)
             node.send_node.loc.dot
+          else
+            end_loc
           end
         end
 

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

@@ -46,10 +46,12 @@ module RuboCop
       #                  .a
       #                  .b
       #                  .c
-      class MultilineMethodCallIndentation < Base
+      #
+      class MultilineMethodCallIndentation < Base # rubocop:disable Metrics/ClassLength
         include ConfigurableEnforcedStyle
         include Alignment
         include MultilineExpressionIndentation
+        include RangeHelp
         extend AutoCorrector
 
         def validate_config
@@ -64,8 +66,39 @@ module RuboCop
 
         private
 
+        def find_base_receiver(node)
+          base_receiver = node
+          base_receiver = base_receiver.receiver while base_receiver.receiver
+          base_receiver
+        end
+
+        def find_pair_ancestor(node)
+          node.each_ancestor.find(&:pair_type?)
+        end
+
+        def unwrap_block_node(node)
+          node&.any_block_type? ? node.send_node : node
+        end
+
         def autocorrect(corrector, node)
-          AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          if @send_node.block_node
+            correct_selector_only(corrector, node)
+            correct_block(corrector, @send_node.block_node)
+          else
+            AlignmentCorrector.correct(corrector, processed_source, node, @column_delta)
+          end
+        end
+
+        def correct_selector_only(corrector, node)
+          selector_line = processed_source.buffer.line_range(node.first_line)
+          selector_range = range_between(selector_line.begin_pos, selector_line.end_pos)
+          AlignmentCorrector.correct(corrector, processed_source, selector_range, @column_delta)
+        end
+
+        def correct_block(corrector, block_node)
+          AlignmentCorrector.correct(corrector, processed_source, block_node.body, @column_delta)
+          end_range = range_by_whole_lines(block_node.loc.end, include_final_newline: false)
+          AlignmentCorrector.correct(corrector, processed_source, end_range, @column_delta)
         end
 
         def relevant_node?(send_node)
@@ -84,11 +117,55 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
-          return false if not_for_this_cop?(node)
 
+          @send_node = node # Store for use in autocorrect
+          pair_ancestor = find_pair_ancestor(node)
+          if hash_pair_aligned?(pair_ancestor, given_style)
+            return check_hash_pair_indentation(node, lhs, rhs)
+          end
+          if hash_pair_indented?(node, pair_ancestor, given_style)
+            return check_hash_pair_indented_style(rhs, pair_ancestor)
+          end
+
+          return false if !pair_ancestor && not_for_this_cop?(node)
+
+          check_regular_indentation(node, lhs, rhs, given_style)
+        end
+
+        def hash_pair_aligned?(pair_ancestor, given_style)
+          pair_ancestor && given_style == :aligned
+        end
+
+        def hash_pair_indented?(node, pair_ancestor, given_style)
+          pair_ancestor && given_style == :indented && find_base_receiver(node).hash_type?
+        end
+
+        def check_hash_pair_indented_style(rhs, pair_ancestor)
+          pair_key = pair_ancestor.key
+          double_indentation = configured_indentation_width * 2
+          correct_column = pair_key.source_range.column + double_indentation
+          @hash_pair_base_column = pair_key.source_range.column + configured_indentation_width
+
+          calculate_column_delta_offense(rhs, correct_column)
+        end
+
+        def check_hash_pair_indentation(node, lhs, rhs)
+          @base = find_hash_pair_alignment_base(node) || lhs.source_range
+
+          calculate_column_delta_offense(rhs, @base.column)
+        end
+
+        def find_hash_pair_alignment_base(node)
+          base_receiver = find_base_receiver(node.receiver)
+          return unless base_receiver.hash_type?
+
+          first_call = first_call_has_a_dot(node)
+          first_call.loc.dot.join(first_call.loc.selector)
+        end
+
+        def check_regular_indentation(node, lhs, rhs, given_style)
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
                              parent = node.parent
@@ -97,20 +174,22 @@ module RuboCop
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
+
+          calculate_column_delta_offense(rhs, correct_column)
+        end
+
+        def calculate_column_delta_offense(rhs, correct_column)
           @column_delta = correct_column - rhs.column
           rhs if @column_delta.nonzero?
         end
-        # rubocop:enable Metrics/AbcSize
 
         def extra_indentation(given_style, parent)
-          if given_style == :indented_relative_to_receiver
-            if parent&.type?(:splat, :kwsplat)
-              configured_indentation_width - parent.loc.operator.length
-            else
-              configured_indentation_width
-            end
+          return 0 unless given_style == :indented_relative_to_receiver
+
+          if parent&.type?(:splat, :kwsplat)
+            configured_indentation_width - parent.loc.operator.length
           else
-            0
+            configured_indentation_width
           end
         end
 
@@ -129,7 +208,7 @@ module RuboCop
         end
 
         def should_align_with_base?
-          @base && style != :indented_relative_to_receiver
+          @base && style == :aligned
         end
 
         def relative_to_receiver_message(rhs)
@@ -146,10 +225,16 @@ module RuboCop
         end
 
         def no_base_message(lhs, rhs, node)
-          used_indentation = rhs.column - indentation(lhs)
+          if @hash_pair_base_column
+            used_indentation = rhs.column - @hash_pair_base_column
+            expected_indentation = configured_indentation_width
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            expected_indentation = correct_indentation(node)
+          end
           what = operation_description(node, rhs)
 
-          "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+          "Use #{expected_indentation} (not #{used_indentation}) " \
             "spaces for indenting #{what} spanning multiple lines."
         end
 
@@ -157,8 +242,6 @@ module RuboCop
           case given_style
           when :aligned
             semantic_alignment_base(node, rhs) || syntactic_alignment_base(node, rhs)
-          when :indented
-            nil
           when :indented_relative_to_receiver
             receiver_alignment_base(node)
           end
@@ -195,29 +278,55 @@ module RuboCop
         #   .b
         #   .c
         def receiver_alignment_base(node)
-          node = node.receiver while node.receiver
-          node = node.parent
-          node = node.parent until node.loc.dot
+          hash_method_base = find_hash_method_base_in_receiver_chain(node)
+          return hash_method_base if hash_method_base
+
+          first_call = first_call_has_a_dot(node)
+          first_call.receiver.source_range
+        end
+
+        def find_hash_method_base_in_receiver_chain(node)
+          receiver_chain = unwrap_block_node(node.receiver)
+          while receiver_chain&.call_type?
+            base_receiver = unwrap_block_node(receiver_chain.receiver)
+            if alignment_base_for_chained_receiver?(receiver_chain, base_receiver)
+              return receiver_chain.loc.dot.join(receiver_chain.loc.selector)
+            end
+
+            receiver_chain = base_receiver
+          end
+        end
 
-          node&.receiver&.source_range
+        def alignment_base_for_chained_receiver?(receiver_chain, base_receiver)
+          base_receiver&.hash_type? ||
+            method_on_receiver_last_line?(receiver_chain, base_receiver, :begin)
         end
 
         def semantic_alignment_node(node)
           return if argument_in_method_call(node, :with_parentheses)
 
-          dot_right_above = get_dot_right_above(node)
-          return dot_right_above if dot_right_above
-
-          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
-            return multiline_block_chain_node
-          end
+          get_dot_right_above(node) ||
+            find_multiline_block_chain_node(node) ||
+            first_call_alignment_node(node)
+        end
 
+        def first_call_alignment_node(node)
           node = first_call_has_a_dot(node)
+          base_receiver = find_base_receiver(node)
+
+          return node if method_on_receiver_last_line?(node, base_receiver, :array)
           return if node.loc.dot.line != node.first_line
+          return if method_on_receiver_last_line?(node, base_receiver, :begin)
 
           node
         end
 
+        def method_on_receiver_last_line?(node, base_receiver, type)
+          base_receiver &&
+            node.loc.dot.line == base_receiver.last_line &&
+            base_receiver.type?(type)
+        end
+
         def get_dot_right_above(node)
           node.each_ancestor.find do |a|
             dot = a.loc.dot if a.loc?(:dot)
@@ -228,23 +337,30 @@ module RuboCop
         end
 
         def find_multiline_block_chain_node(node)
-          return unless (block_node = node.each_descendant(:any_block).first)
-          return unless block_node.multiline? && block_node.parent.call_type?
+          return find_continuation_receiver(node) if node.block_node
 
-          if node.receiver.call_type?
-            node.receiver
-          else
-            block_node.parent
-          end
+          handle_descendant_block(node)
+        end
+
+        def find_continuation_receiver(node)
+          receiver = node.receiver
+          return unless receiver.call_type? && receiver.loc.dot && receiver.receiver
+          return unless receiver.loc.dot.line > receiver.receiver.last_line
+
+          receiver
+        end
+
+        def handle_descendant_block(node)
+          block_node = node.each_descendant(:any_block).first
+          return unless block_node&.multiline?
+
+          node.receiver.call_type? ? node.receiver : block_node.parent
         end
 
         def first_call_has_a_dot(node)
-          # descend to root of method chain
-          node = node.receiver while node.receiver
-          # ascend to first call which has a dot
-          node = node.parent
+          base = find_base_receiver(node)
+          node = base.parent
           node = node.parent until node.loc?(:dot)
-
           node
         end
 

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

@@ -137,6 +137,17 @@ module RuboCop
       #     true
       #   end
       #
+      # @example WaywardPredicates: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   def non_predicate_method(num)
+      #     num.infinite?
+      #   end
+      #
+      #   # good
+      #   def non_predicate_method(num)
+      #     num.nonzero?
+      #   end
+      #
       class PredicateMethod < Base
         include AllowedMethods
         include AllowedPattern

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

@@ -196,7 +196,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, node, condition, replacement, guard)
           corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
 
@@ -205,10 +205,10 @@ module RuboCop
 
           corrector.replace(node.loc.begin, "\n") if node.then?
 
-          if if_branch&.send_type? && heredoc?(if_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)
-          elsif else_branch&.send_type? && heredoc?(else_branch.last_argument)
-            autocorrect_heredoc_argument(corrector, node, else_branch, if_branch, guard)
+          if (if_heredoc = find_heredoc_argument(if_branch))
+            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
+          elsif (else_heredoc = find_heredoc_argument(else_branch))
+            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
           else
             corrector.remove(node.loc.end)
             return unless node.else?
@@ -217,21 +217,31 @@ module RuboCop
             corrector.remove(range_of_branch_to_remove(node, guard))
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize
 
         def heredoc?(argument)
           argument.respond_to?(:heredoc?) && argument.heredoc?
         end
 
-        def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard)
+        def find_heredoc_argument(node)
+          return unless node&.call_type?
+
+          last_arg = node.last_argument
+
+          if heredoc?(last_arg)
+            last_arg
+          elsif last_arg&.call_type?
+            find_heredoc_argument(last_arg)
+          end
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
           remove_whole_lines(corrector, node.loc.end)
           return unless node.else?
 
           if leave_branch
             remove_whole_lines(corrector, leave_branch.source_range)
-            corrector.insert_after(
-              heredoc_branch.last_argument.loc.heredoc_end, "\n#{leave_branch.source}"
-            )
+            corrector.insert_after(heredoc_node.loc.heredoc_end, "\n#{leave_branch.source}")
           end
 
           remove_whole_lines(corrector, node.loc.else)

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

@@ -71,7 +71,8 @@ module RuboCop
       #   if short_condition # a long comment that makes it too long if it were just a single line
       #     do_something
       #   end
-      class IfUnlessModifier < Base
+      #
+      class IfUnlessModifier < Base # rubocop:disable Metrics/ClassLength
         include StatementModifier
         include LineLengthHelp
         include AllowedPattern
@@ -230,15 +231,6 @@ module RuboCop
           true
         end
 
-        def too_long_line_based_on_allow_qualified_name?(line)
-          if allow_qualified_name?
-            namespace_range = find_excessive_range(line, :namespace)
-            return false if namespace_range && allowed_position?(line, namespace_range)
-          end
-
-          true
-        end
-
         def line_length_enabled_at_line?(line)
           processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
         end
@@ -248,7 +240,44 @@ module RuboCop
         end
 
         def non_eligible_node?(node)
-          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? ||
+            multiline_inside_collection?(node) || super
+        end
+
+        def multiline_inside_collection?(node)
+          return false if node.modifier_form?
+          return false unless (collection = find_containing_collection(node))
+
+          collection.children.any? { |child| sibling_if_shares_line?(child, node) }
+        end
+
+        def sibling_if_shares_line?(child, node)
+          inner = unwrap_begin(child)
+          inner&.if_type? && shares_line_with?(inner, node)
+        end
+
+        def unwrap_begin(node)
+          return unless node.is_a?(RuboCop::AST::Node)
+
+          node = node.value if node.pair_type?
+          node.begin_type? ? node.children.first : node
+        end
+
+        def shares_line_with?(inner, node)
+          inner.loc.line == node.loc.end.line || inner.loc.end.line == node.loc.line
+        end
+
+        def find_containing_collection(node)
+          parent = node.parent
+          return collection_from_ancestor(parent) unless parent&.begin_type?
+
+          collection_from_ancestor(parent.parent)
+        end
+
+        def collection_from_ancestor(node)
+          return node if node&.type?(:array, :call)
+
+          node.parent if node&.type?(:pair)
         end
 
         def non_simple_if_unless?(node)

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

@@ -54,7 +54,10 @@ module RuboCop
       #   # good (but potentially an unsafe correction)
       #   foo.do_something?
       #
-      # @example AllowedMethods: ['nonzero?'] (default)
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
       #   # good
       #   num.nonzero? ? true : false
       #

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

@@ -42,7 +42,7 @@ module RuboCop
       #   Array.public_method_defined?(:foo)
       #   Array.include?(:foo)
       #
-      #  @example AllowedMethods: [included_modules]
+      # @example AllowedMethods: [included_modules]
       #
       #   # good
       #   Array.included_modules.include?(:foo)

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

@@ -182,6 +182,8 @@ module RuboCop
         end
 
         def receivers_match?(length_receiver, array_receiver)
+          return array_receiver.self_type? unless length_receiver
+
           unless preserving_method?(array_receiver) && preserving_method?(length_receiver)
             return false
           end

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

@@ -58,7 +58,10 @@ module RuboCop
       #   # good
       #   a.nil? || a
       #
-      # @example AllowedMethods: ['nonzero?'] (default)
+      # @example AllowedMethods: ['infinite?', 'nonzero?'] (default)
+      #   # good
+      #   num.infinite? ? true : false
+      #
       #   # good
       #   num.nonzero? ? true : false
       #

data/lib/rubocop/cop/team.rb

@@ -177,8 +177,8 @@ module RuboCop
       # @return [Array<cop>]
       def roundup_relevant_cops(processed_source)
         cops.select do |cop|
-          next true if processed_source.comment_config.cop_opted_in?(cop)
           next false if cop.excluded_file?(processed_source.file_path)
+          next true if processed_source.comment_config.cop_opted_in?(cop)
           next false unless @registry.enabled?(cop, @config)
 
           support_target_ruby_version?(cop) && support_target_rails_version?(cop)

data/lib/rubocop/lsp/diagnostic.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'disable_comment_edits'
 require_relative 'severity'
 
 #
@@ -16,11 +17,12 @@ module RuboCop
     # Diagnostic for Language Server Protocol of RuboCop.
     # @api private
     class Diagnostic
-      def initialize(document_encoding, offense, uri, cop_class)
+      def initialize(document_encoding, offense, uri, cop_class, processed_source = nil)
         @document_encoding = document_encoding
         @offense = offense
         @uri = uri
         @cop_class = cop_class
+        @processed_source = processed_source
       end
 
       def to_lsp_code_actions
@@ -141,25 +143,11 @@ module RuboCop
       # rubocop:enable Metrics/MethodLength
 
       def line_disable_comment
-        new_text = if @offense.source_line.include?(' # rubocop:disable ')
-                     ",#{@offense.cop_name}"
-                   else
-                     " # rubocop:disable #{@offense.cop_name}"
-                   end
-
-        eol = LanguageServer::Protocol::Interface::Position.new(
-          line: @offense.line - 1,
-          character: to_position_character(@offense.source_line.length)
-        )
-
-        # TODO: fails for multiline strings - may be preferable to use block
-        # comments to disable some offenses
-        inline_comment = LanguageServer::Protocol::Interface::TextEdit.new(
-          range: LanguageServer::Protocol::Interface::Range.new(start: eol, end: eol),
-          new_text: new_text
-        )
-
-        [inline_comment]
+        DisableCommentEdits.new(
+          offense: @offense,
+          document_encoding: @document_encoding,
+          processed_source: @processed_source
+        ).edits
       end
 
       def to_position_character(utf8_index)

data/lib/rubocop/lsp/disable_comment_edits.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module LSP
+    # Builds LSP text edits for rubocop:disable comments.
+    # @api private
+    class DisableCommentEdits
+      def initialize(offense:, document_encoding:, processed_source:)
+        @offense = offense
+        @document_encoding = document_encoding
+        @processed_source = processed_source
+      end
+
+      def edits
+        literal_range = multiline_literal_range
+        return block_disable_comments(literal_range) if literal_range
+
+        inline_disable_comment
+      end
+
+      private
+
+      def inline_disable_comment
+        eol = position(@offense.line - 1, @offense.source_line.length, @offense.source_line)
+        [text_edit(eol, inline_comment_text)]
+      end
+
+      def inline_comment_text
+        if @offense.source_line.include?(' # rubocop:disable ')
+          ",#{@offense.cop_name}"
+        else
+          " # rubocop:disable #{@offense.cop_name}"
+        end
+      end
+
+      def block_disable_comments(range)
+        full_line_range = range_by_lines(range)
+        leading_whitespace = full_line_range.source_line[/^\s*/].to_s
+        [
+          disable_edit(full_line_range.first_line, leading_whitespace),
+          enable_edit(full_line_range, leading_whitespace)
+        ]
+      end
+
+      def disable_edit(first_line, leading_whitespace)
+        position = position(first_line - 1, 0, '')
+        text_edit(position, "#{leading_whitespace}# rubocop:disable #{@offense.cop_name}\n")
+      end
+
+      def enable_edit(full_line_range, leading_whitespace)
+        last_line = full_line_range.last_line
+        last_line_text = full_line_range.source_buffer.source_line(last_line)
+        position = position(last_line - 1, last_line_text.length, last_line_text)
+        text_edit(position, "\n#{leading_whitespace}# rubocop:enable #{@offense.cop_name}")
+      end
+
+      def text_edit(position, new_text)
+        range = LanguageServer::Protocol::Interface::Range.new(start: position, end: position)
+        LanguageServer::Protocol::Interface::TextEdit.new(range: range, new_text: new_text)
+      end
+
+      def position(line, utf8_index, line_text)
+        LanguageServer::Protocol::Interface::Position.new(
+          line: line,
+          character: position_character(utf8_index, line_text)
+        )
+      end
+
+      def position_character(utf8_index, line_text)
+        str = line_text[0, utf8_index]
+        if @document_encoding == Encoding::UTF_16LE || @document_encoding.nil?
+          str.length + str.b.count("\xf0-\xff".b)
+        else
+          str.length
+        end
+      end
+
+      def multiline_literal_range
+        return unless @processed_source&.ast
+
+        offense_range = @offense.location
+        multiline_ranges&.find do |range|
+          eol_comment_would_be_inside_literal?(offense_range, range)
+        end
+      end
+
+      def multiline_ranges
+        @processed_source.ast.each_node.filter_map do |node|
+          if surrounding_heredoc?(node)
+            heredoc_range(node)
+          elsif string_continuation?(node)
+            range_by_lines(node.source_range)
+          elsif surrounding_percent_array?(node) || multiline_string?(node)
+            node.source_range
+          end
+        end
+      end
+
+      def eol_comment_would_be_inside_literal?(offense_range, literal_range)
+        offense_line = offense_range.line
+        offense_line >= literal_range.first_line && offense_line < literal_range.last_line
+      end
+
+      def surrounding_heredoc?(node)
+        node.any_str_type? && node.heredoc?
+      end
+
+      def heredoc_range(node)
+        node.source_range.join(node.loc.heredoc_end)
+      end
+
+      def surrounding_percent_array?(node)
+        node.array_type? && node.percent_literal?
+      end
+
+      def string_continuation?(node)
+        node.any_str_type? && node.source.match?(/\\\s*$/)
+      end
+
+      def multiline_string?(node)
+        node.dstr_type? && node.multiline?
+      end
+
+      def range_by_lines(range)
+        begin_of_first_line = range.begin_pos - range.column
+
+        last_line = range.source_buffer.source_line(range.last_line)
+        last_line_offset = last_line.length - range.last_column
+        end_of_last_line = range.end_pos + last_line_offset
+
+        Parser::Source::Range.new(range.source_buffer, begin_of_first_line, end_of_last_line)
+      end
+    end
+  end
+end

data/lib/rubocop/lsp/runtime.rb

@@ -49,15 +49,25 @@ module RuboCop
         diagnostic_options[:only] = config_only_options if @lint_mode || @layout_mode
 
         @runner.run(path, text, diagnostic_options, prism_result: prism_result)
+        processed_source = @runner.processed_source
+        config = @runner.config_for_working_directory
         @runner.offenses.map do |offense|
-          Diagnostic.new(
-            document_encoding, offense, path, @cop_registry[offense.cop_name]&.first
-          ).to_lsp_diagnostic(@runner.config_for_working_directory)
+          build_diagnostic(offense, path, document_encoding, processed_source, config)
         end
       end
 
       private
 
+      def build_diagnostic(offense, path, document_encoding, processed_source, config)
+        Diagnostic.new(
+          document_encoding,
+          offense,
+          path,
+          @cop_registry[offense.cop_name]&.first,
+          processed_source
+        ).to_lsp_diagnostic(config)
+      end
+
       def config_only_options
         only_options = []
         only_options << 'Lint' if @lint_mode

data/lib/rubocop/lsp/stdin_runner.rb

@@ -17,7 +17,7 @@ module RuboCop
     class StdinRunner < RuboCop::Runner
       class ConfigurationError < StandardError; end
 
-      attr_reader :offenses, :config_for_working_directory
+      attr_reader :offenses, :config_for_working_directory, :processed_source
 
       DEFAULT_RUBOCOP_OPTIONS = {
         stderr: true,
@@ -45,6 +45,7 @@ module RuboCop
         @options[:stdin] = contents
 
         @prism_result = prism_result
+        @processed_source = nil
 
         @offenses = []
         @warnings = []
@@ -64,6 +65,12 @@ module RuboCop
       def file_finished(_file, offenses)
         @offenses = offenses
       end
+
+      def do_inspection_loop(file)
+        source, offenses = super
+        @processed_source = source
+        [source, offenses]
+      end
     end
   end
 end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.84.0'
+    STRING = '1.84.1'
 
     MSG = '%<version>s (using %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.84.0
+  version: 1.84.1
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -1038,6 +1038,7 @@ files:
 - lib/rubocop/lockfile.rb
 - lib/rubocop/lsp.rb
 - lib/rubocop/lsp/diagnostic.rb
+- lib/rubocop/lsp/disable_comment_edits.rb
 - lib/rubocop/lsp/logger.rb
 - lib/rubocop/lsp/routes.rb
 - lib/rubocop/lsp/runtime.rb
@@ -1096,7 +1097,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.84.0
+  changelog_uri: https://github.com/rubocop/rubocop/releases/tag/v1.84.1
   source_code_uri: https://github.com/rubocop/rubocop/
   documentation_uri: https://docs.rubocop.org/rubocop/1.84/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues